1/* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import hilog from '@ohos.hilog'; 17import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect, TestType, Level, Size } from '@ohos/hypium'; 18 19import {checkError, createProgram, getColorUint8Array,clear,WEBGL2_FRAGMENT_SHADER_DEMO} from './WebGL2'; 20 21 22export default function webgl2_buffer() { 23 24 describe('webgl2_buffer', function () { 25 let gl = global.gl2; 26 // Defines a test suite. Two parameters are supported: test suite name and test suite function. 27 beforeAll(function () { 28 hilog.info(0x0000, 'testTag', '%{public}s', 'webgl1_test_01 start'); 29 // Presets an action, which is performed only once before all test cases of the test suite start. 30 // This API supports only one parameter: preset action function. 31 }); 32 beforeEach(function () { 33 // Presets an action, which is performed before each unit test case starts. 34 // The number of execution times is the same as the number of test cases defined by **it**. 35 // This API supports only one parameter: preset action function. 36 checkError(gl); 37 }); 38 afterEach(function () { 39 // Presets a clear action, which is performed after each unit test case ends. 40 // The number of execution times is the same as the number of test cases defined by **it**. 41 // This API supports only one parameter: clear action function. 42 checkError(gl); 43 }); 44 afterAll(function () { 45 // Presets a clear action, which is performed after all test cases of the test suite end. 46 // This API supports only one parameter: clear action function. 47 hilog.info(0x0000, 'testTag', '%{public}s', 'webgl1_test_01 end'); 48 }); 49 function copyBufferSubData(callback, finish) { 50 let p = createProgram(gl, `#version 300 es 51 in vec4 a_position; 52 in vec3 a_color; 53 out vec3 v_color; 54 void main(){ 55 gl_Position = a_position; 56 gl_PointSize = 100.0; 57 v_color = a_color; 58 } 59 `, `#version 300 es 60 precision mediump float; 61 in vec3 v_color; 62 out vec4 color; 63 void main(){ 64 color = vec4(v_color,1.0); 65 } 66 `); 67 let source = new Float32Array([ 68 -1.0, -1.0, 1.0, 0.0, 0.0, 69 -1.0, 1.0, 0.0, 1.0, 0.0, 70 1.0, 1.0, 0.0, 0.0, 1.0, 71 1.0, -1.0, 0.0, 0.0, 0.0, 72 ]); 73 let FSIZE = source.BYTES_PER_ELEMENT; 74 let srcBuffer = gl.createBuffer(); //Create a buffer 75 gl.bindBuffer(gl.ARRAY_BUFFER, srcBuffer); //bound buffer 76 gl.bufferData(gl.ARRAY_BUFFER, source, gl.STATIC_READ, 0, 20); //writes data to a buffer object 77 gl.bindBuffer(gl.COPY_READ_BUFFER, srcBuffer); //gl.COPY_READ_BUFFER A buffer used to copy from one buffer object to another 78 let dstBuffer = gl.createBuffer(); 79 gl.bindBuffer(gl.ARRAY_BUFFER, dstBuffer); 80 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(source.length), gl.STATIC_READ, 0, 20); //gl.STATIC_DRAW data is written to the buffer object only once 81 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 82 callback(); 83 let a_position = gl.getAttribLocation(p.program, 'a_position'); 84 gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 5 * FSIZE, 0); 85 gl.enableVertexAttribArray(a_position); 86 let a_color = gl.getAttribLocation(p.program, 'a_color'); 87 gl.vertexAttribPointer(a_color, 3, gl.FLOAT, false, 5 * FSIZE, 2 * FSIZE); 88 gl.enableVertexAttribArray(a_color); 89 gl.clearColor(0.8, 0.8, 0.8, 1.0); 90 gl.clear(gl.COLOR_BUFFER_BIT); 91 gl.drawArrays(gl.POINTS, 0, 4); 92 let result = new Uint8Array(2 * 2 * 4); 93 gl.readPixels(0, 0, 2, 2, gl.RGBA, gl.UNSIGNED_BYTE, result); 94 console.info("webgltest ", result); 95 finish(); 96 gl.deleteBuffer(srcBuffer); 97 gl.deleteBuffer(dstBuffer); 98 gl.deleteShader(p.vertexShader); 99 gl.deleteShader(p.fragmentShader); 100 gl.deleteProgram(p.program); 101 gl.flush(); 102 } 103 /** 104 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0001 105 * @tc.name webgl2_test_copyBufferSubData 106 * @tc.desc Test copyBufferSubData. 107 */ 108 it('webgl2_test_copyBufferSubData', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 109 console.info("webgl2test [webgl2_test_copyBufferSubData] copyBufferSubData"); 110 let p = createProgram(gl, `#version 300 es 111 in vec4 a_position; 112 in vec3 a_color; 113 out vec3 v_color; 114 void main(){ 115 gl_Position = a_position; 116 gl_PointSize = 100.0; 117 v_color = a_color; 118 } 119 `, `#version 300 es 120 precision mediump float; 121 in vec3 v_color; 122 out vec4 color; 123 void main(){ 124 color = vec4(v_color,1.0); 125 } 126 `); 127 let source = new Float32Array([ 128 -1.0, -1.0, 1.0, 0.0, 0.0, 129 -1.0, 1.0, 0.0, 1.0, 0.0, 130 1.0, 1.0, 0.0, 0.0, 1.0, 131 1.0, -1.0, 0.0, 0.0, 0.0, 132 ]); 133 let FSIZE = source.BYTES_PER_ELEMENT; 134 let srcBuffer = gl.createBuffer(); //create buffer 135 gl.bindBuffer(gl.ARRAY_BUFFER, srcBuffer); //bound buffer 136 gl.bufferData(gl.ARRAY_BUFFER, source, gl.STATIC_READ, 0, 20); //writes data to a buffer object 137 gl.bindBuffer(gl.COPY_READ_BUFFER, srcBuffer); //gl.COPY_READ_BUFFER A buffer used to copy from one buffer object to another 138 let dstBuffer = gl.createBuffer(); 139 gl.bindBuffer(gl.ARRAY_BUFFER, dstBuffer); 140 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(source.length), gl.STATIC_READ, 0, 20); //gl.STATIC_DRAW data is written to the buffer object only once 141 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 142 gl.copyBufferSubData(gl.COPY_READ_BUFFER, gl.ARRAY_BUFFER, 0 * FSIZE, 0 * FSIZE, 20 * FSIZE); 143 let a_position = gl.getAttribLocation(p.program, 'a_position'); 144 gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 5 * FSIZE, 0); 145 gl.enableVertexAttribArray(a_position); 146 let a_color = gl.getAttribLocation(p.program, 'a_color'); 147 gl.vertexAttribPointer(a_color, 3, gl.FLOAT, false, 5 * FSIZE, 2 * FSIZE); 148 gl.enableVertexAttribArray(a_color); 149 gl.clearColor(0.8, 0.8, 0.8, 1.0); 150 gl.clear(gl.COLOR_BUFFER_BIT); 151 gl.drawArrays(gl.POINTS, 0, 4); 152 let result = new Uint8Array(2 * 2 * 4); 153 gl.readPixels(0, 0, 2, 2, gl.RGBA, gl.UNSIGNED_BYTE, result); 154 console.info("webgltest ", result); 155 expect(result[0]).assertEqual(255); 156 expect(result[1]).assertEqual(0); 157 expect(result[2]).assertEqual(0); 158 expect(result[3]).assertEqual(255); 159 gl.deleteBuffer(srcBuffer); 160 gl.deleteBuffer(dstBuffer); 161 gl.deleteShader(p.vertexShader); 162 gl.deleteShader(p.fragmentShader); 163 gl.deleteProgram(p.program); 164 gl.flush(); 165 done(); 166 }); 167 /** 168 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0002 169 * @tc.name webgl2_test_copyBufferSubData_1 170 * @tc.desc Test copyBufferSubData. 171 */ 172 it('webgl2_test_copyBufferSubData_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 173 async function (done) { 174 let source = new Float32Array([ 175 -1.0, -1.0, 1.0, 0.0, 0.0, 176 -1.0, 1.0, 0.0, 1.0, 0.0, 177 1.0, 1.0, 0.0, 0.0, 1.0, 178 1.0, -1.0, 0.0, 0.0, 0.0, 179 ]); 180 let FSIZE = source.BYTES_PER_ELEMENT; 181 copyBufferSubData(() => { 182 gl.copyBufferSubData(gl.COPY_WRITE_BUFFER, gl.ARRAY_BUFFER, 0 * FSIZE, 0 * FSIZE, 20 * FSIZE); 183 }, () => { 184 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 185 }); 186 done(); 187 }); 188 /** 189 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0003 190 * @tc.name webgl2_test_copyBufferSubData_2 191 * @tc.desc Test copyBufferSubData. 192 */ 193 it('webgl2_test_copyBufferSubData_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 194 async function (done) { 195 let source = new Float32Array([ 196 -1.0, -1.0, 1.0, 0.0, 0.0, 197 -1.0, 1.0, 0.0, 1.0, 0.0, 198 1.0, 1.0, 0.0, 0.0, 1.0, 199 1.0, -1.0, 0.0, 0.0, 0.0, 200 ]); 201 let FSIZE = source.BYTES_PER_ELEMENT; 202 copyBufferSubData(() => { 203 gl.copyBufferSubData(gl.TRANSFORM_FEEDBACK_BUFFER, gl.ARRAY_BUFFER, 0 * FSIZE, 0 * FSIZE, 20 * FSIZE); 204 }, () => { 205 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 206 }); 207 done(); 208 }); 209 /** 210 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0004 211 * @tc.name webgl2_test_copyBufferSubData_3 212 * @tc.desc Test copyBufferSubData. 213 */ 214 it('webgl2_test_copyBufferSubData_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 215 async function (done) { 216 let source = new Float32Array([ 217 -1.0, -1.0, 1.0, 0.0, 0.0, 218 -1.0, 1.0, 0.0, 1.0, 0.0, 219 1.0, 1.0, 0.0, 0.0, 1.0, 220 1.0, -1.0, 0.0, 0.0, 0.0, 221 ]); 222 let FSIZE = source.BYTES_PER_ELEMENT; 223 copyBufferSubData(() => { 224 gl.copyBufferSubData(gl.UNIFORM_BUFFER, gl.ARRAY_BUFFER, 0 * FSIZE, 0 * FSIZE, 20 * FSIZE); 225 }, () => { 226 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 227 }); 228 done(); 229 }); 230 /** 231 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0005 232 * @tc.name webgl2_test_copyBufferSubData_4 233 * @tc.desc Test copyBufferSubData. 234 */ 235 it('webgl2_test_copyBufferSubData_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 236 async function (done) { 237 let source = new Float32Array([ 238 -1.0, -1.0, 1.0, 0.0, 0.0, 239 -1.0, 1.0, 0.0, 1.0, 0.0, 240 1.0, 1.0, 0.0, 0.0, 1.0, 241 1.0, -1.0, 0.0, 0.0, 0.0, 242 ]); 243 let FSIZE = source.BYTES_PER_ELEMENT; 244 copyBufferSubData(() => { 245 gl.copyBufferSubData(gl.PIXEL_PACK_BUFFER, gl.ARRAY_BUFFER, 0 * FSIZE, 0 * FSIZE, 20 * FSIZE); 246 }, () => { 247 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 248 }); 249 done(); 250 }); 251 /** 252 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0006 253 * @tc.name webgl2_test_copyBufferSubData_5 254 * @tc.desc Test copyBufferSubData. 255 */ 256 it('webgl2_test_copyBufferSubData_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 257 async function (done) { 258 let source = new Float32Array([ 259 -1.0, -1.0, 1.0, 0.0, 0.0, 260 -1.0, 1.0, 0.0, 1.0, 0.0, 261 1.0, 1.0, 0.0, 0.0, 1.0, 262 1.0, -1.0, 0.0, 0.0, 0.0, 263 ]); 264 let FSIZE = source.BYTES_PER_ELEMENT; 265 copyBufferSubData(() => { 266 gl.copyBufferSubData(gl.PIXEL_UNPACK_BUFFER, gl.ARRAY_BUFFER, 0 * FSIZE, 0 * FSIZE, 20 * FSIZE); 267 }, () => { 268 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 269 }); 270 done(); 271 }); 272 function getBufferSubData(callback, finish) { 273 console.info("webgl2test [webgl2_test_getBufferSubData] getBufferSubData"); 274 let p = createProgram(gl, `#version 300 es 275 in vec4 a_position; 276 in vec3 a_color; 277 out vec3 v_color; 278 void main(){ 279 gl_Position = a_position; 280 gl_PointSize = 100.0; 281 v_color = a_color; 282 } 283 `, `#version 300 es 284 precision mediump float; 285 in vec3 v_color; 286 out vec4 color; 287 void main(){ 288 color = vec4(v_color,1.0); 289 } 290 `); 291 let source = new Float32Array([ 292 -1.0, -1.0, 1.0, 0.0, 0.0, 293 -1.0, 1.0, 0.0, 1.0, 0.0, 294 1.0, 1.0, 0.0, 0.0, 1.0, 295 1.0, -1.0, 0.0, 0.0, 0.0, 296 ]); 297 let FSIZE = source.BYTES_PER_ELEMENT; 298 let buffer = gl.createBuffer(); 299 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); 300 gl.bufferData(gl.ARRAY_BUFFER, source, gl.STATIC_DRAW, 0, 20); 301 let a_position = gl.getAttribLocation(p.program, 'a_position'); 302 gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 5 * FSIZE, 0); 303 gl.enableVertexAttribArray(a_position); 304 let a_color = gl.getAttribLocation(p.program, 'a_color'); 305 gl.vertexAttribPointer(a_color, 3, gl.FLOAT, false, 5 * FSIZE, 2 * FSIZE); 306 gl.enableVertexAttribArray(a_color); 307 gl.clearColor(0.8, 0.8, 0.8, 1.0); 308 gl.clear(gl.COLOR_BUFFER_BIT); 309 gl.drawArrays(gl.TRIANGLE_FAN, 0, 4); 310 let result = new Float32Array(5); 311 callback(source, result); 312 finish(); 313 gl.disableVertexAttribArray(a_color); 314 gl.disableVertexAttribArray(a_position); 315 gl.deleteBuffer(buffer); 316 gl.deleteShader(p.vertexShader); 317 gl.deleteShader(p.fragmentShader); 318 gl.deleteProgram(p.program); 319 gl.flush(); 320 } 321 /** 322 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0007 323 * @tc.name webgl2_test_getBufferSubData_1 324 * @tc.desc Test getBufferSubData. 325 */ 326 it('webgl2_test_getBufferSubData_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 327 async function (done) { 328 getBufferSubData((source, result) => { 329 gl.getBufferSubData(gl.ELEMENT_ARRAY_BUFFER, 5 * source.BYTES_PER_ELEMENT, result, 0, 5); 330 }, () => { 331 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 332 }); 333 done(); 334 }); 335 /** 336 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0008 337 * @tc.name webgl2_test_getBufferSubData_2 338 * @tc.desc Test getBufferSubData. 339 */ 340 it('webgl2_test_getBufferSubData_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 341 async function (done) { 342 getBufferSubData((source, result) => { 343 gl.getBufferSubData(gl.COPY_READ_BUFFER, 5 * source.BYTES_PER_ELEMENT, result, 0, 5); 344 }, () => { 345 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 346 }); 347 done(); 348 }); 349 /** 350 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0009 351 * @tc.name webgl2_test_getBufferSubData_3 352 * @tc.desc Test getBufferSubData. 353 */ 354 it('webgl2_test_getBufferSubData_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 355 async function (done) { 356 getBufferSubData((source, result) => { 357 gl.getBufferSubData(gl.COPY_WRITE_BUFFER, 5 * source.BYTES_PER_ELEMENT, result, 0, 5); 358 }, () => { 359 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 360 }); 361 done(); 362 }); 363 /** 364 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0010 365 * @tc.name webgl2_test_getBufferSubData_4 366 * @tc.desc Test getBufferSubData. 367 */ 368 it('webgl2_test_getBufferSubData_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 369 async function (done) { 370 getBufferSubData((source, result) => { 371 gl.getBufferSubData(gl.TRANSFORM_FEEDBACK_BUFFER, 5 * source.BYTES_PER_ELEMENT, result, 0, 5); 372 }, () => { 373 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 374 }); 375 done(); 376 }); 377 /** 378 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0011 379 * @tc.name webgl2_test_getBufferSubData_5 380 * @tc.desc Test getBufferSubData. 381 */ 382 it('webgl2_test_getBufferSubData_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 383 async function (done) { 384 getBufferSubData((source, result) => { 385 gl.getBufferSubData(gl.UNIFORM_BUFFER, 5 * source.BYTES_PER_ELEMENT, result, 0, 5); 386 }, () => { 387 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 388 }); 389 done(); 390 }); 391 /** 392 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0012 393 * @tc.name webgl2_test_getBufferSubData 394 * @tc.desc Test getBufferSubData. 395 */ 396 it('webgl2_test_getBufferSubData', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 397 console.info("webgl2test [webgl2_test_getBufferSubData] getBufferSubData"); 398 let p = createProgram(gl, `#version 300 es 399 in vec4 a_position; 400 in vec3 a_color; 401 out vec3 v_color; 402 void main(){ 403 gl_Position = a_position; 404 gl_PointSize = 100.0; 405 v_color = a_color; 406 } 407 `, `#version 300 es 408 precision mediump float; 409 in vec3 v_color; 410 out vec4 color; 411 void main(){ 412 color = vec4(v_color,1.0); 413 } 414 `); 415 let source = new Float32Array([ 416 -1.0, -1.0, 1.0, 0.0, 0.0, 417 -1.0, 1.0, 0.0, 1.0, 0.0, 418 1.0, 1.0, 0.0, 0.0, 1.0, 419 1.0, -1.0, 0.0, 0.0, 0.0, 420 ]); 421 let FSIZE = source.BYTES_PER_ELEMENT; 422 let buffer = gl.createBuffer(); 423 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); 424 gl.bufferData(gl.ARRAY_BUFFER, source, gl.STATIC_DRAW, 0, 20); 425 let a_position = gl.getAttribLocation(p.program, 'a_position'); 426 gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 5 * FSIZE, 0); 427 gl.enableVertexAttribArray(a_position); 428 let a_color = gl.getAttribLocation(p.program, 'a_color'); 429 gl.vertexAttribPointer(a_color, 3, gl.FLOAT, false, 5 * FSIZE, 2 * FSIZE); 430 gl.enableVertexAttribArray(a_color); 431 gl.clearColor(0.8, 0.8, 0.8, 1.0); 432 gl.clear(gl.COLOR_BUFFER_BIT); 433 gl.drawArrays(gl.TRIANGLE_FAN, 0, 4); 434 let result = new Float32Array(5); 435 gl.getBufferSubData(gl.ARRAY_BUFFER, 5 * source.BYTES_PER_ELEMENT, result, 0, 5); 436 console.info("webgltest", result); 437 expect(result[0]).assertEqual(-1); 438 expect(result[1]).assertEqual(1); 439 expect(result[2]).assertEqual(0); 440 expect(result[3]).assertEqual(1); 441 expect(result[4]).assertEqual(0); 442 gl.disableVertexAttribArray(a_color); 443 gl.disableVertexAttribArray(a_position); 444 gl.deleteBuffer(buffer); 445 gl.deleteShader(p.vertexShader); 446 gl.deleteShader(p.fragmentShader); 447 gl.deleteProgram(p.program); 448 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 449 gl.flush(); 450 done(); 451 }); 452 function blitFramebuffer(callback, finish) { 453 let srcViewport = gl.getParameter(gl.VIEWPORT); 454 let p = createProgram(gl, `#version 300 es 455 void main(){ 456 gl_Position = vec4(-1.0,-1.0,0.0,1.0); 457 gl_PointSize = 300.0; 458 } 459 `, `#version 300 es 460 precision mediump float; 461 out vec4 color; 462 void main(){ 463 color = vec4(1.0,0.0,0.0,1.0); 464 } 465 `); 466 let width = 1, height = 1; 467 let fb1 = gl.createFramebuffer(); 468 gl.bindFramebuffer(gl.FRAMEBUFFER, fb1); 469 let texture1 = gl.createTexture(); 470 gl.bindTexture(gl.TEXTURE_2D, texture1); 471 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); 472 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture1, 0); 473 gl.viewport(0, 0, width, height); 474 gl.clearColor(1.0, 0.0, 0.0, 1.0); 475 gl.clear(gl.COLOR_BUFFER_BIT); 476 gl.drawArrays(gl.POINTS, 0, 1); 477 let res = new Uint8Array(width * height * 4); 478 gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, res); 479 console.info("webgltest", res); 480 let fb2 = gl.createFramebuffer(); 481 gl.bindFramebuffer(gl.FRAMEBUFFER, fb2); 482 let texture2 = gl.createTexture(); 483 gl.bindTexture(gl.TEXTURE_2D, texture2); 484 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); 485 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture2, 0); 486 gl.bindFramebuffer(gl.READ_FRAMEBUFFER, fb1); 487 gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, fb2); 488 callback(width, height); 489 gl.bindFramebuffer(gl.FRAMEBUFFER, fb2); 490 let res2 = new Uint8Array(width * height * 4); 491 gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, res2); 492 console.info("webgltest", res2); 493 finish(res2); 494 gl.viewport(srcViewport[0], srcViewport[1], srcViewport[2], srcViewport[3]); 495 gl.bindFramebuffer(gl.FRAMEBUFFER, null); 496 gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null); 497 gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null); 498 gl.deleteFramebuffer(fb1); 499 gl.deleteFramebuffer(fb2); 500 gl.deleteTexture(texture1); 501 gl.deleteTexture(texture2); 502 gl.deleteShader(p.vertexShader); 503 gl.deleteShader(p.fragmentShader); 504 gl.deleteProgram(p.program); 505 gl.flush(); 506 } 507 /** 508 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0013 509 * @tc.name webgl2_test_blitFramebuffer 510 * @tc.desc Test blitFramebuffer. 511 */ 512 it('webgl2_test_blitFramebuffer', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 513 console.info("webgl2test [webgl2_test_blitFramebuffer] blitFramebuffer"); 514 blitFramebuffer((width, height) => { 515 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.COLOR_BUFFER_BIT, gl.NEAREST); 516 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 517 }, (res) => { 518 expect(res[0]).assertEqual(255); 519 expect(res[1]).assertEqual(0); 520 expect(res[2]).assertEqual(0); 521 expect(res[3]).assertEqual(255); 522 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 523 }); 524 done(); 525 }); 526 /** 527 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0014 528 * @tc.name webgl2_test_blitFramebuffer_1 529 * @tc.desc Test blitFramebuffer. 530 */ 531 it('webgl2_test_blitFramebuffer_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 532 console.info("webgl2test [webgl2_test_blitFramebuffer_1] blitFramebuffer"); 533 blitFramebuffer((width, height) => { 534 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.STENCIL_BUFFER_BIT, gl.NEAREST); 535 }, () => { 536 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 537 }); 538 done(); 539 }); 540 /** 541 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0015 542 * @tc.name webgl2_test_blitFramebuffer_2 543 * @tc.desc Test blitFramebuffer. 544 */ 545 it('webgl2_test_blitFramebuffer_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 546 console.info("webgl2test [webgl2_test_blitFramebuffer_2] blitFramebuffer"); 547 blitFramebuffer((width, height) => { 548 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.DEPTH_BUFFER_BIT, gl.NEAREST); 549 }, () => { 550 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 551 }); 552 done(); 553 }); 554 /** 555 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0016 556 * @tc.name webgl2_test_blitFramebuffer_3 557 * @tc.desc Test blitFramebuffer. 558 */ 559 it('webgl2_test_blitFramebuffer_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 560 console.info("webgl2test [webgl2_test_blitFramebuffer_3] blitFramebuffer"); 561 blitFramebuffer((width, height) => { 562 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.DEPTH_BUFFER_BIT, gl.LINEAR); 563 }, () => { 564 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 565 }); 566 done(); 567 }); 568 /** 569 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0017 570 * @tc.name webgl2_test_blitFramebuffer_4 571 * @tc.desc Test blitFramebuffer. 572 */ 573 it('webgl2_test_blitFramebuffer_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 574 console.info("webgl2test [webgl2_test_blitFramebuffer_4] blitFramebuffer"); 575 blitFramebuffer((width, height) => { 576 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.STENCIL_BUFFER_BIT, gl.LINEAR); 577 }, () => { 578 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 579 }); 580 done(); 581 }); 582 function framebufferTextureLayer(callback, finish) { 583 let srcViewPort = gl.getParameter(gl.VIEWPORT); 584 let width = 8, height = 8, depth = 3; 585 let data = new Uint8Array(width * height * depth * 4); 586 let colors = [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255]]; 587 for (let i = 0; i < depth; i++) { 588 data.set(getColorUint8Array(width, height, colors[i][0], colors[i][1], colors[i][2], colors[i][3]), width * height * 4 * i); 589 } 590 let a_position = 0, a_texcoord = 1; 591 let vCode = `#version 300 es 592 layout(location=0) in vec4 a_position; 593 layout(location=1) in vec2 a_texcoord; 594 out vec2 v_texcoord; 595 void main(){ 596 gl_Position = a_position; 597 v_texcoord = a_texcoord; 598 } 599 `; 600 let fCode = `#version 300 es 601 precision mediump float; 602 precision highp int; 603 precision mediump sampler2DArray; 604 605 uniform sampler2DArray u_sampler; 606 in vec2 v_texcoord; 607 uniform int u_depth; 608 out vec4 color; 609 void main(){ 610 color = texture(u_sampler,vec3(v_texcoord,float(u_depth))); 611 } 612 `; 613 let source = [ 614 -1, -1, 0, 1, 615 1, 1, 1, 0, 616 -1, 1, 0, 0, 617 -1, -1, 0, 1, 618 1, -1, 1, 1, 619 1, 1, 1, 0, 620 ]; 621 let p1 = createProgram(gl, vCode, fCode); 622 gl.useProgram(p1.program); 623 gl.activeTexture(gl.TEXTURE0); 624 //texture 625 let texture = gl.createTexture(); 626 gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture); 627 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.LINEAR); 628 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.LINEAR); 629 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_BASE_LEVEL, 0); 630 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAX_LEVEL, 0); 631 gl.texImage3D(gl.TEXTURE_2D_ARRAY, 0, gl.RGBA, width, height, depth, 0, gl.RGBA, gl.UNSIGNED_BYTE, data); 632 //renderTexture 633 let renderTexture = gl.createTexture(); 634 gl.bindTexture(gl.TEXTURE_2D_ARRAY, renderTexture); 635 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.LINEAR); 636 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.LINEAR); 637 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_BASE_LEVEL, 0); 638 gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAX_LEVEL, 0); 639 gl.texImage3D(gl.TEXTURE_2D_ARRAY, 0, gl.RGBA, width, height, depth, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); 640 //framebuffer 641 let framebuffer = gl.createFramebuffer(); 642 let renderbuffer = gl.createRenderbuffer(); 643 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 644 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); 645 gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, width, height); 646 let useDep = callback(renderTexture); 647 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer); 648 gl.viewport(0, 0, width, height); 649 gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture); 650 let buffer = gl.createBuffer(); 651 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); 652 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(source), gl.STATIC_DRAW); 653 gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 4 * 4, 0); 654 gl.vertexAttribPointer(a_texcoord, 2, gl.FLOAT, false, 4 * 4, 2 * 4); 655 gl.enableVertexAttribArray(a_position); 656 gl.enableVertexAttribArray(a_texcoord); 657 let u_depth1 = gl.getUniformLocation(p1.program, 'u_depth'); 658 gl.uniform1i(u_depth1, useDep); 659 gl.clearColor(0, 0, 0, 1.0); 660 gl.clear(gl.COLOR_BUFFER_BIT); 661 gl.drawArrays(gl.TRIANGLES, 0, 6); 662 gl.readBuffer(gl.COLOR_ATTACHMENT0); 663 let p2 = createProgram(gl, vCode, fCode); 664 gl.useProgram(p2.program); 665 gl.viewport(srcViewPort[0], srcViewPort[1], srcViewPort[2], srcViewPort[3]); 666 gl.bindFramebuffer(gl.FRAMEBUFFER, null); 667 gl.bindTexture(gl.TEXTURE_2D_ARRAY, renderTexture); 668 let buffer2 = gl.createBuffer(); 669 gl.bindBuffer(gl.ARRAY_BUFFER, buffer2); 670 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(source), gl.STATIC_DRAW); 671 gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 4 * 4, 0); 672 gl.vertexAttribPointer(a_texcoord, 2, gl.FLOAT, false, 4 * 4, 2 * 4); 673 let u_depth2 = gl.getUniformLocation(p2.program, 'u_depth'); 674 gl.uniform1i(u_depth2, useDep); 675 let u_sampler = gl.getUniformLocation(p2.program, 'u_sampler'); 676 gl.uniform1i(u_sampler, 0); 677 gl.enableVertexAttribArray(a_position); 678 gl.enableVertexAttribArray(a_texcoord); 679 gl.clearColor(0, 0, 0, 1.0); 680 gl.clear(gl.COLOR_BUFFER_BIT); 681 gl.drawArrays(gl.TRIANGLES, 0, 6); 682 let res = new Uint8Array(width * height * 4); 683 gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, res); 684 finish(res); 685 gl.flush(); 686 } 687 /** 688 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0018 689 * @tc.name webgl2_test_framebufferTextureLayer 690 * @tc.desc Test framebufferTextureLayer. 691 */ 692 it('webgl2_test_framebufferTextureLayer', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 693 async function (done) { 694 console.info("webgl2test [webgl2_test_framebufferTextureLayer] framebufferTextureLayer"); 695 framebufferTextureLayer((renderTexture) => { 696 let layer = 2; 697 gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, renderTexture, 0, layer); 698 return layer; 699 }, (res) => { 700 console.log(res); 701 expect(res[0]).assertEqual(0); 702 expect(res[1]).assertEqual(0); 703 expect(res[2]).assertEqual(255); 704 expect(res[3]).assertEqual(255); 705 }); 706 done(); 707 }); 708 /** 709 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0019 710 * @tc.name webgl2_test_framebufferTextureLayer_1 711 * @tc.desc Test framebufferTextureLayer. 712 */ 713 it('webgl2_test_framebufferTextureLayer_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 714 async function (done) { 715 console.info("webgl2test [webgl2_test_framebufferTextureLayer] framebufferTextureLayer"); 716 framebufferTextureLayer((renderTexture) => { 717 let layer = 2; 718 gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, renderTexture, 0, layer); 719 return layer; 720 }, (res) => { 721 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 722 }); 723 done(); 724 }); 725 /** 726 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0020 727 * @tc.name webgl2_test_framebufferTextureLayer_2 728 * @tc.desc Test framebufferTextureLayer. 729 */ 730 it('webgl2_test_framebufferTextureLayer_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 731 async function (done) { 732 console.info("webgl2test [webgl2_test_framebufferTextureLayer] framebufferTextureLayer"); 733 framebufferTextureLayer((renderTexture) => { 734 let layer = 2; 735 gl.framebufferTextureLayer(gl.READ_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, renderTexture, 0, layer); 736 return layer; 737 }, (res) => { 738 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 739 }); 740 done(); 741 }); 742 /** 743 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0021 744 * @tc.name webgl2_test_framebufferTextureLayer_3 745 * @tc.desc Test framebufferTextureLayer. 746 */ 747 it('webgl2_test_framebufferTextureLayer_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 748 async function (done) { 749 console.info("webgl2test [webgl2_test_framebufferTextureLayer] framebufferTextureLayer"); 750 framebufferTextureLayer((renderTexture) => { 751 let layer = 2; 752 gl.framebufferTextureLayer(gl.READ_FRAMEBUFFER, gl.DEPTH_ATTACHMENT, renderTexture, 0, layer); 753 return layer; 754 }, (res) => { 755 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 756 }); 757 done(); 758 }); 759 /** 760 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0022 761 * @tc.name webgl2_test_framebufferTextureLayer_4 762 * @tc.desc Test framebufferTextureLayer. 763 */ 764 it('webgl2_test_framebufferTextureLayer_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 765 async function (done) { 766 console.info("webgl2test [webgl2_test_framebufferTextureLayer] framebufferTextureLayer"); 767 framebufferTextureLayer((renderTexture) => { 768 let layer = 2; 769 gl.framebufferTextureLayer(gl.READ_FRAMEBUFFER, gl.STENCIL_ATTACHMENT, renderTexture, 0, layer); 770 return layer; 771 }, (res) => { 772 expect(checkError(gl)).assertEqual(gl.INVALID_FRAMEBUFFER_OPERATION); 773 }); 774 done(); 775 }); 776 /** 777 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0023 778 * @tc.name webgl2_test_framebufferTextureLayer_5 779 * @tc.desc Test framebufferTextureLayer. 780 */ 781 it('webgl2_test_framebufferTextureLayer_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 782 async function (done) { 783 console.info("webgl2test [webgl2_test_framebufferTextureLayer] framebufferTextureLayer"); 784 framebufferTextureLayer((renderTexture) => { 785 let layer = 2; 786 gl.framebufferTextureLayer(gl.READ_FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, renderTexture, 0, layer); 787 return layer; 788 }, (res) => { 789 expect(checkError(gl)).assertEqual(gl.INVALID_FRAMEBUFFER_OPERATION); 790 }); 791 done(); 792 }); 793 /** 794 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0024 795 * @tc.name webgl2_test_invalidateFramebuffer 796 * @tc.desc Test invalidateFramebuffer. 797 */ 798 it('webgl2_test_invalidateFramebuffer', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 799 async function (done) { 800 console.info("webgl2test [webgl2_test_invalidateFramebuffer] invalidateFramebuffer"); 801 let framebuffer = gl.createFramebuffer(); 802 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 803 gl.invalidateFramebuffer(gl.FRAMEBUFFER, [gl.COLOR_ATTACHMENT0]); 804 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 805 gl.deleteFramebuffer(framebuffer); 806 done(); 807 }); 808 /** 809 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0025 810 * @tc.name webgl2_test_invalidateFramebuffer_1 811 * @tc.desc Test invalidateFramebuffer. 812 */ 813 it('webgl2_test_invalidateFramebuffer_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 814 async function (done) { 815 console.info("webgl2test [webgl2_test_invalidateFramebuffer] invalidateFramebuffer"); 816 let framebuffer = gl.createFramebuffer(); 817 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 818 gl.invalidateFramebuffer(gl.DRAW_FRAMEBUFFER, [gl.COLOR_ATTACHMENT0]); 819 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 820 gl.deleteFramebuffer(framebuffer); 821 done(); 822 }); 823 /** 824 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0026 825 * @tc.name webgl2_test_invalidateFramebuffer_2 826 * @tc.desc Test invalidateFramebuffer. 827 */ 828 it('webgl2_test_invalidateFramebuffer_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 829 async function (done) { 830 console.info("webgl2test [webgl2_test_invalidateFramebuffer] invalidateFramebuffer"); 831 let framebuffer = gl.createFramebuffer(); 832 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 833 gl.invalidateFramebuffer(gl.READ_FRAMEBUFFER, [gl.COLOR_ATTACHMENT0]); 834 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 835 gl.deleteFramebuffer(framebuffer); 836 done(); 837 }); 838 /** 839 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0027 840 * @tc.name webgl2_test_invalidateFramebuffer_3 841 * @tc.desc Test invalidateFramebuffer. 842 */ 843 it('webgl2_test_invalidateFramebuffer_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 844 async function (done) { 845 console.info("webgl2test [webgl2_test_invalidateFramebuffer] invalidateFramebuffer"); 846 let framebuffer = gl.createFramebuffer(); 847 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 848 gl.invalidateFramebuffer(gl.READ_FRAMEBUFFER, [gl.COLOR_ATTACHMENT1]); 849 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 850 gl.deleteFramebuffer(framebuffer); 851 done(); 852 }); 853 /** 854 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0028 855 * @tc.name webgl2_test_invalidateFramebuffer_4 856 * @tc.desc Test invalidateFramebuffer. 857 */ 858 it('webgl2_test_invalidateFramebuffer_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 859 async function (done) { 860 console.info("webgl2test [webgl2_test_invalidateFramebuffer] invalidateFramebuffer"); 861 let framebuffer = gl.createFramebuffer(); 862 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 863 gl.invalidateFramebuffer(gl.READ_FRAMEBUFFER, [gl.COLOR_ATTACHMENT2]); 864 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 865 gl.deleteFramebuffer(framebuffer); 866 done(); 867 }); 868 function readBuffer(callback, finish) { 869 const framebuffer = gl.createFramebuffer(); 870 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 871 const texture1 = gl.createTexture(); 872 gl.bindTexture(gl.TEXTURE_2D, texture1); 873 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 4, 4, 0, gl.RGBA, gl.UNSIGNED_BYTE, getColorUint8Array(4, 4, 255, 0, 0, 255)); 874 callback(texture1); 875 const pixels = new Uint8Array(4 * 4 * 4); 876 gl.readPixels(0, 0, 4, 4, gl.RGBA, gl.UNSIGNED_BYTE, pixels); 877 finish(pixels); 878 gl.bindFramebuffer(gl.FRAMEBUFFER, null); 879 gl.bindTexture(gl.TEXTURE_2D, null); 880 gl.deleteTexture(texture1); 881 gl.deleteFramebuffer(framebuffer); 882 gl.flush(); 883 } 884 /** 885 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0029 886 * @tc.name webgl2_test_readBuffer 887 * @tc.desc Test readBuffer. 888 */ 889 it('webgl2_test_readBuffer', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 890 //Method selects a color buffer as the pixel's source for subsequent calls to copyTexImage2D, copyTexSubImage2D, copyTexSubImage3D, or readPixels. 891 console.info("webgl2test [webgl2_test_readBuffer] readBuffer"); 892 readBuffer((texture) => { 893 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); 894 gl.readBuffer(gl.COLOR_ATTACHMENT0); 895 }, (pixels) => { 896 expect(pixels[0]).assertEqual(255); 897 expect(pixels[1]).assertEqual(0); 898 expect(pixels[2]).assertEqual(0); 899 expect(pixels[3]).assertEqual(255); 900 }); 901 done(); 902 }); 903 /** 904 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0030 905 * @tc.name webgl2_test_readBuffer_1 906 * @tc.desc Test readBuffer. 907 */ 908 it('webgl2_test_readBuffer_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 909 console.info("webgl2test [webgl2_test_readBuffer] readBuffer"); 910 readBuffer((texture) => { 911 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); 912 gl.readBuffer(gl.BACK); 913 }, (pixels) => { 914 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 915 }); 916 done(); 917 }); 918 /** 919 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0031 920 * @tc.name webgl2_test_readBuffer_2 921 * @tc.desc Test readBuffer. 922 */ 923 it('webgl2_test_readBuffer_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 924 console.info("webgl2test [webgl2_test_readBuffer] readBuffer"); 925 readBuffer((texture) => { 926 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); 927 gl.readBuffer(gl.NONE); 928 }, (pixels) => { 929 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 930 }); 931 done(); 932 }); 933 /** 934 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0032 935 * @tc.name webgl2_test_readBuffer_3 936 * @tc.desc Test readBuffer. 937 */ 938 it('webgl2_test_readBuffer_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 939 console.info("webgl2test [webgl2_test_readBuffer] readBuffer"); 940 readBuffer((texture) => { 941 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); 942 gl.readBuffer(gl.COLOR_ATTACHMENT1); 943 }, (pixels) => { 944 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 945 }); 946 done(); 947 }); 948 /** 949 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0033 950 * @tc.name webgl2_test_readBuffer_4 951 * @tc.desc Test readBuffer. 952 */ 953 it('webgl2_test_readBuffer_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 954 console.info("webgl2test [webgl2_test_readBuffer] readBuffer"); 955 readBuffer((texture) => { 956 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); 957 gl.readBuffer(gl.COLOR_ATTACHMENT2); 958 }, (pixels) => { 959 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 960 }); 961 done(); 962 }); 963 function getInternalformatParameter(callback, finish) { 964 const renderbuffer = gl.createRenderbuffer(); 965 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); 966 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, 4, gl.RGBA8, 256, 256); 967 callback(); 968 finish(); 969 gl.deleteRenderbuffer(renderbuffer); 970 } 971 /** 972 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0034 973 * @tc.name webgl2_test_getInternalformatParameter 974 * @tc.desc Test getInternalformatParameter. 975 */ 976 it('webgl2_test_getInternalformatParameter', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 977 async function (done) { 978 console.info("webgl2test [webgl2_test_getInternalformatParameter] getInternalformatParameter"); 979 const renderbuffer = gl.createRenderbuffer(); 980 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); 981 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, 4, gl.RGBA8, 256, 256); 982 const samples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA8, gl.SAMPLES); 983 console.log(`Internal format parameter value:`, samples); 984 expect(samples.byteLength > 0).assertEqual(true); 985 gl.bindRenderbuffer(gl.RENDERBUFFER, null); 986 gl.deleteRenderbuffer(renderbuffer); 987 gl.flush(); 988 done(); 989 }); 990 /** 991 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0035 992 * @tc.name webgl2_test_getInternalformatParameter_1 993 * @tc.desc Test getInternalformatParameter. 994 */ 995 it('webgl2_test_getInternalformatParameter_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 996 async function (done) { 997 console.info("webgl2test [webgl2_test_getInternalformatParameter_1] getInternalformatParameter"); 998 readBuffer((texture) => { 999 const samples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA8I, gl.SAMPLES); 1000 expect(samples.byteLength).assertEqual(0); 1001 }, (pixels) => { 1002 expect(checkError(gl)).assertEqual(gl.INVALID_FRAMEBUFFER_OPERATION); 1003 }); 1004 done(); 1005 }); 1006 /** 1007 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0036 1008 * @tc.name webgl2_test_getInternalformatParameter_2 1009 * @tc.desc Test getInternalformatParameter. 1010 */ 1011 it('webgl2_test_getInternalformatParameter_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1012 async function (done) { 1013 console.info("webgl2test [webgl2_test_getInternalformatParameter_2] getInternalformatParameter"); 1014 readBuffer((texture) => { 1015 const samples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA16I, gl.SAMPLES); 1016 expect(samples.byteLength).assertEqual(0); 1017 }, (pixels) => { 1018 expect(checkError(gl)).assertEqual(gl.INVALID_FRAMEBUFFER_OPERATION); 1019 }); 1020 done(); 1021 }); 1022 /** 1023 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0037 1024 * @tc.name webgl2_test_getInternalformatParameter_3 1025 * @tc.desc Test getInternalformatParameter. 1026 */ 1027 it('webgl2_test_getInternalformatParameter_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1028 async function (done) { 1029 console.info("webgl2test [webgl2_test_getInternalformatParameter_3] getInternalformatParameter"); 1030 readBuffer((texture) => { 1031 const samples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA16UI, gl.SAMPLES); 1032 expect(samples.byteLength).assertEqual(0); 1033 }, (pixels) => { 1034 expect(checkError(gl)).assertEqual(gl.INVALID_FRAMEBUFFER_OPERATION); 1035 }); 1036 done(); 1037 }); 1038 function renderbufferStorageMultisample(callback, finish) { 1039 const renderbuffer = gl.createRenderbuffer(); 1040 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); 1041 const samples = 4; 1042 const internalFormat = gl.RGBA8; 1043 const width = 256; 1044 const height = 256; 1045 callback(samples, internalFormat, width, height); 1046 finish(); 1047 const maxSamples = gl.getParameter(gl.MAX_SAMPLES); 1048 const actualSamples = gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_SAMPLES); 1049 console.info("webgltest", "Max supported samples: ", maxSamples); 1050 console.info("webgltest", "Actual samples used: ", actualSamples); 1051 gl.deleteRenderbuffer(renderbuffer); 1052 } 1053 /** 1054 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0038 1055 * @tc.name webgl2_test_renderbufferStorageMultisample 1056 * @tc.desc Test renderbufferStorageMultisample. 1057 */ 1058 it('webgl2_test_renderbufferStorageMultisample', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1059 async function (done) { 1060 console.info("webgl2test [webgl2_test_renderbufferStorageMultisample] renderbufferStorageMultisample"); 1061 const renderbuffer = gl.createRenderbuffer(); 1062 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); 1063 const samples = 4; // set the number of samples for multiple sampling 1064 const internalFormat = gl.RGBA8; 1065 const width = 256; 1066 const height = 256; 1067 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, samples, internalFormat, width, height); 1068 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1069 const maxSamples = gl.getParameter(gl.MAX_SAMPLES); 1070 const actualSamples = gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_SAMPLES); 1071 console.info("webgltest", "Max supported samples: ", maxSamples); 1072 console.info("webgltest", "Actual samples used: ", actualSamples); 1073 expect(gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH)).assertEqual(256); 1074 expect(gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT)).assertEqual(256); 1075 expect(gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_INTERNAL_FORMAT)).assertEqual(gl.RGBA8); 1076 gl.deleteRenderbuffer(renderbuffer); 1077 done(); 1078 }); 1079 /** 1080 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0039 1081 * @tc.name webgl2_test_renderbufferStorageMultisample_1 1082 * @tc.desc Test renderbufferStorageMultisample. 1083 */ 1084 it('webgl2_test_renderbufferStorageMultisample_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1085 async function (done) { 1086 renderbufferStorageMultisample((samples, internalFormat, width, height) => { 1087 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, samples, gl.R8, width, height); 1088 }, () => { 1089 expect(gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_INTERNAL_FORMAT)).assertEqual(gl.R8); 1090 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1091 }); 1092 done(); 1093 }); 1094 /** 1095 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0040 1096 * @tc.name webgl2_test_renderbufferStorageMultisample_2 1097 * @tc.desc Test renderbufferStorageMultisample. 1098 */ 1099 it('webgl2_test_renderbufferStorageMultisample_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1100 async function (done) { 1101 renderbufferStorageMultisample((samples, internalFormat, width, height) => { 1102 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, samples, gl.R8UI, width, height); 1103 }, () => { 1104 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 1105 }); 1106 done(); 1107 }); 1108 /** 1109 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0041 1110 * @tc.name webgl2_test_renderbufferStorageMultisample_3 1111 * @tc.desc Test renderbufferStorageMultisample. 1112 */ 1113 it('webgl2_test_renderbufferStorageMultisample_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1114 async function (done) { 1115 renderbufferStorageMultisample((samples, internalFormat, width, height) => { 1116 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, samples, gl.R32UI, width, height); 1117 }, () => { 1118 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 1119 }); 1120 done(); 1121 }); 1122 /** 1123 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0042 1124 * @tc.name webgl2_test_renderbufferStorageMultisample_4 1125 * @tc.desc Test renderbufferStorageMultisample. 1126 */ 1127 it('webgl2_test_renderbufferStorageMultisample_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1128 async function (done) { 1129 renderbufferStorageMultisample((samples, internalFormat, width, height) => { 1130 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, samples, gl.RG16UI, width, height); 1131 }, () => { 1132 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 1133 }); 1134 done(); 1135 }); 1136 function vertexAttribDivisor(callback, finish) { 1137 let p = createProgram(gl, `#version 300 es 1138 layout(location=0) in vec2 position; 1139 layout(location=1) in vec3 color; 1140 layout(location=2) in float instanceId; 1141 out vec3 vColor; 1142 void main() { 1143 gl_Position = vec4(position.x + instanceId , position.y, 0.0, 1.0); 1144 vColor = color; 1145 } 1146 `, `#version 300 es 1147 precision highp float; 1148 in vec3 vColor; 1149 out vec4 fragColor; 1150 void main() { 1151 fragColor = vec4(vColor, 1.0); 1152 } 1153 `); 1154 const vertices = [ 1155 -1.0, -1.0, 1.0, 0.0, 0.0, 1156 -1.0, 1.0, 1.0, 0.0, 0.0, 1157 1.0, -1.0, 1.0, 0.0, 0.0, 1158 ]; 1159 const divisor = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]; 1160 const vbo = gl.createBuffer(); 1161 gl.bindBuffer(gl.ARRAY_BUFFER, vbo); 1162 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW); 1163 gl.enableVertexAttribArray(0); 1164 gl.enableVertexAttribArray(1); 1165 gl.enableVertexAttribArray(2); 1166 gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 5 * 4, 0); 1167 gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 5 * 4, 2 * 4); 1168 let buf2 = gl.createBuffer(); 1169 gl.bindBuffer(gl.ARRAY_BUFFER, buf2); 1170 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(divisor), gl.STATIC_DRAW); 1171 gl.vertexAttribPointer(2, 1, gl.FLOAT, false, 1 * 4, 0); // set to update once per instance 1172 callback(); 1173 gl.clearColor(1.0, 0.0, 0.0, 1.0); 1174 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); 1175 gl.drawArraysInstanced(gl.TRIANGLES, 0, 3, divisor.length); 1176 let pixels = new Uint8Array(4); 1177 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels); 1178 finish(pixels); 1179 gl.disableVertexAttribArray(0); 1180 gl.disableVertexAttribArray(1); 1181 gl.disableVertexAttribArray(2); 1182 gl.deleteBuffer(vbo); 1183 gl.deleteBuffer(buf2); 1184 gl.deleteShader(p.vertexShader); 1185 gl.deleteShader(p.fragmentShader); 1186 gl.deleteProgram(p.program); 1187 gl.flush(); 1188 } 1189 /** 1190 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0043 1191 * @tc.name webgl2_test_vertexAttribDivisor 1192 * @tc.desc Test vertexAttribDivisor. 1193 */ 1194 it('webgl2_test_vertexAttribDivisor', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1195 async function (done) { 1196 console.info("webgl2test [webgl2_test_vertexAttribDivisor] vertexAttribDivisor"); 1197 vertexAttribDivisor(() => { 1198 gl.vertexAttribDivisor(2, 1); 1199 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1200 }, (res) => { 1201 console.info("webgltest", res); 1202 expect(res[0]).assertEqual(255); 1203 expect(res[1]).assertEqual(0); 1204 expect(res[2]).assertEqual(0); 1205 expect(res[3]).assertEqual(255); 1206 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1207 }); 1208 done(); 1209 }); 1210 /** 1211 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0044 1212 * @tc.name webgl2_test_vertexAttribDivisor_1 1213 * @tc.desc Test vertexAttribDivisor. 1214 */ 1215 it('webgl2_test_vertexAttribDivisor_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1216 async function (done) { 1217 console.info("webgl2test [webgl2_test_vertexAttribDivisor_1] vertexAttribDivisor"); 1218 vertexAttribDivisor(() => { 1219 gl.vertexAttribDivisor(2, 0); 1220 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1221 }, (res) => { 1222 console.info("webgltest", res); 1223 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1224 checkError(gl); 1225 }); 1226 done(); 1227 }); 1228 /** 1229 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0045 1230 * @tc.name webgl2_test_vertexAttribDivisor_2 1231 * @tc.desc Test vertexAttribDivisor. 1232 */ 1233 it('webgl2_test_vertexAttribDivisor_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1234 async function (done) { 1235 console.info("webgl2test [webgl2_test_vertexAttribDivisor_2] vertexAttribDivisor"); 1236 vertexAttribDivisor(() => { 1237 gl.vertexAttribDivisor(2, -1); 1238 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1239 }, (res) => { 1240 console.info("webgltest", res); 1241 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1242 checkError(gl); 1243 }); 1244 done(); 1245 }); 1246 /** 1247 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0046 1248 * @tc.name webgl2_test_vertexAttribDivisor_3 1249 * @tc.desc Test vertexAttribDivisor. 1250 */ 1251 it('webgl2_test_vertexAttribDivisor_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1252 async function (done) { 1253 console.info("webgl2test [webgl2_test_vertexAttribDivisor_3] vertexAttribDivisor"); 1254 vertexAttribDivisor(() => { 1255 gl.vertexAttribDivisor(2, 2); 1256 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1257 }, (res) => { 1258 console.info("webgltest", res); 1259 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1260 checkError(gl); 1261 }); 1262 done(); 1263 }); 1264 /** 1265 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0047 1266 * @tc.name webgl2_test_vertexAttribDivisor_4 1267 * @tc.desc Test vertexAttribDivisor. 1268 */ 1269 it('webgl2_test_vertexAttribDivisor_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1270 async function (done) { 1271 console.info("webgl2test [webgl2_test_vertexAttribDivisor_4] vertexAttribDivisor"); 1272 vertexAttribDivisor(() => { 1273 gl.vertexAttribDivisor(2, 100); 1274 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1275 }, (res) => { 1276 console.info("webgltest", res); 1277 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1278 checkError(gl); 1279 }); 1280 done(); 1281 }); 1282 function drawArraysInstanced(callback, finish) { 1283 let p = createProgram(gl, `#version 300 es 1284 layout(location=0) in vec2 position; 1285 layout(location=1) in vec3 color; 1286 layout(location=2) in float instanceId; 1287 out vec3 vColor; 1288 void main() { 1289 gl_Position = vec4(position.x + instanceId , position.y, 0.0, 1.0); 1290 gl_PointSize = 100.0; 1291 vColor = color; 1292 } 1293 `, `#version 300 es 1294 precision highp float; 1295 in vec3 vColor; 1296 out vec4 fragColor; 1297 void main() { 1298 fragColor = vec4(vColor, 1.0); 1299 } 1300 `); 1301 const vertices = [ 1302 -1.0, -1.0, 1.0, 0.0, 0.0, 1303 -1.0, 1.0, 1.0, 0.0, 0.0, 1304 1.0, -1.0, 1.0, 0.0, 0.0, 1305 ]; 1306 const divisor = [0.0, 0.2, 0.4]; 1307 const vbo = gl.createBuffer(); 1308 gl.bindBuffer(gl.ARRAY_BUFFER, vbo); 1309 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW); 1310 gl.enableVertexAttribArray(0); 1311 gl.enableVertexAttribArray(1); 1312 gl.enableVertexAttribArray(2); 1313 gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 5 * 4, 0); 1314 gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 5 * 4, 2 * 4); 1315 let buf2 = gl.createBuffer(); 1316 gl.bindBuffer(gl.ARRAY_BUFFER, buf2); 1317 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(divisor), gl.STATIC_DRAW); 1318 gl.vertexAttribPointer(2, 1, gl.FLOAT, false, 1 * 4, 0); 1319 gl.vertexAttribDivisor(2, 1); // set to update once per instance 1320 gl.clearColor(0.0, 1.0, 1.0, 1.0); 1321 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); 1322 callback(divisor); 1323 let pixels = new Uint8Array(4); 1324 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels); 1325 finish(pixels); 1326 gl.disableVertexAttribArray(0); 1327 gl.disableVertexAttribArray(1); 1328 gl.disableVertexAttribArray(2); 1329 gl.deleteBuffer(buf2); 1330 gl.deleteBuffer(vbo); 1331 gl.deleteShader(p.vertexShader); 1332 gl.deleteShader(p.fragmentShader); 1333 gl.deleteProgram(p.program); 1334 gl.flush(); 1335 } 1336 /** 1337 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0048 1338 * @tc.name webgl2_test_drawArraysInstanced 1339 * @tc.desc Test drawArraysInstanced. 1340 */ 1341 it('webgl2_test_drawArraysInstanced', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1342 async function (done) { 1343 console.info("webgl2test [webgl2_test_drawArraysInstanced] drawArraysInstanced"); 1344 drawArraysInstanced((divisor) => { 1345 gl.drawArraysInstanced(gl.TRIANGLES, 0, 3, divisor.length); 1346 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1347 }, (res) => { 1348 console.info("webgltest", res); 1349 expect(res[0]).assertEqual(255); 1350 expect(res[1]).assertEqual(0); 1351 expect(res[2]).assertEqual(0); 1352 expect(res[3]).assertEqual(255); 1353 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1354 }); 1355 done(); 1356 }); 1357 /** 1358 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0049 1359 * @tc.name webgl2_test_drawArraysInstanced_1 1360 * @tc.desc Test drawArraysInstanced. 1361 */ 1362 it('webgl2_test_drawArraysInstanced_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1363 async function (done) { 1364 console.info("webgl2test [webgl2_test_drawArraysInstanced_1] drawArraysInstanced"); 1365 drawArraysInstanced((divisor) => { 1366 gl.drawArraysInstanced(gl.POINTS, 0, 3, divisor.length); 1367 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1368 }, (res) => { 1369 console.info("webgltest", res); 1370 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1371 }); 1372 done(); 1373 }); 1374 /** 1375 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0050 1376 * @tc.name webgl2_test_drawArraysInstanced_2 1377 * @tc.desc Test drawArraysInstanced. 1378 */ 1379 it('webgl2_test_drawArraysInstanced_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1380 async function (done) { 1381 console.info("webgl2test [webgl2_test_drawArraysInstanced_2] drawArraysInstanced"); 1382 drawArraysInstanced((divisor) => { 1383 gl.drawArraysInstanced(gl.LINE_STRIP, 0, 3, divisor.length); 1384 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1385 }, (res) => { 1386 console.info("webgltest", res); 1387 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1388 }); 1389 done(); 1390 }); 1391 /** 1392 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0051 1393 * @tc.name webgl2_test_drawArraysInstanced_3 1394 * @tc.desc Test drawArraysInstanced. 1395 */ 1396 it('webgl2_test_drawArraysInstanced_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1397 async function (done) { 1398 console.info("webgl2test [webgl2_test_drawArraysInstanced_3] drawArraysInstanced"); 1399 drawArraysInstanced((divisor) => { 1400 gl.drawArraysInstanced(gl.LINE_STRIP, 0, 3, divisor.length); 1401 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1402 }, (res) => { 1403 console.info("webgltest", res); 1404 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1405 }); 1406 done(); 1407 }); 1408 /** 1409 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0052 1410 * @tc.name webgl2_test_drawArraysInstanced_4 1411 * @tc.desc Test drawArraysInstanced. 1412 */ 1413 it('webgl2_test_drawArraysInstanced_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1414 async function (done) { 1415 console.info("webgl2test [webgl2_test_drawArraysInstanced_4] drawArraysInstanced"); 1416 drawArraysInstanced((divisor) => { 1417 gl.drawArraysInstanced(gl.LINE_LOOP, 0, 3, divisor.length); 1418 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1419 }, (res) => { 1420 console.info("webgltest", res); 1421 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1422 }); 1423 done(); 1424 }); 1425 function drawElementsInstanced(callback, finish) { 1426 let p = createProgram(gl, `#version 300 es 1427 layout(location=0) in vec2 position; 1428 layout(location=1) in vec3 color; 1429 layout(location=2) in float instanceId; 1430 out vec3 vColor; 1431 void main() { 1432 gl_Position = vec4(position.x + instanceId , position.y, 0.0, 1.0); 1433 vColor = color; 1434 } 1435 `, `#version 300 es 1436 precision highp float; 1437 in vec3 vColor; 1438 out vec4 fragColor; 1439 void main() { 1440 fragColor = vec4(vColor, 1.0); 1441 } 1442 `); 1443 const vertices = [ 1444 -1.0, -1.0, 1.0, 0.0, 0.0, 1445 -1.0, 1.0, 1.0, 0.0, 0.0, 1446 1.0, 1.0, 1.0, 0.0, 1.0, 1447 1.0, -1.0, 0.0, 0.0, 1.0, 1448 ]; 1449 const indices = new Uint8Array([0, 1, 3, 1, 2, 3]); 1450 const divisor = [0.0, 0.2, 0.4]; 1451 const vbo = gl.createBuffer(); 1452 gl.bindBuffer(gl.ARRAY_BUFFER, vbo); 1453 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW); 1454 gl.enableVertexAttribArray(0); 1455 gl.enableVertexAttribArray(1); 1456 gl.enableVertexAttribArray(2); 1457 gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 5 * 4, 0); 1458 gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 5 * 4, 2 * 4); 1459 let buf2 = gl.createBuffer(); 1460 gl.bindBuffer(gl.ARRAY_BUFFER, buf2); 1461 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(divisor), gl.STATIC_DRAW); 1462 gl.vertexAttribPointer(2, 1, gl.FLOAT, false, 1 * 4, 0); 1463 gl.vertexAttribDivisor(2, 1); // set to update once per instance 1464 let indexBuffer = gl.createBuffer(); 1465 gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer); 1466 gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW); 1467 gl.clearColor(0.0, 1.0, 1.0, 1.0); 1468 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); 1469 callback(indices, divisor); 1470 let pixels = new Uint8Array(4); 1471 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels); 1472 finish(pixels); 1473 gl.disableVertexAttribArray(0); 1474 gl.disableVertexAttribArray(1); 1475 gl.disableVertexAttribArray(2); 1476 gl.deleteBuffer(indexBuffer); 1477 gl.deleteBuffer(buf2); 1478 gl.deleteBuffer(vbo); 1479 gl.deleteShader(p.vertexShader); 1480 gl.deleteShader(p.fragmentShader); 1481 gl.deleteProgram(p.program); 1482 gl.flush(); 1483 } 1484 /** 1485 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0053 1486 * @tc.name webgl2_test_drawElementsInstanced 1487 * @tc.desc Test drawElementsInstanced. 1488 */ 1489 it('webgl2_test_drawElementsInstanced', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1490 async function (done) { 1491 console.info("webgl2test [webgl2_test_drawElementsInstanced] drawElementsInstanced"); 1492 drawElementsInstanced((indices, divisor) => { 1493 gl.drawElementsInstanced(gl.TRIANGLES, indices.length, gl.UNSIGNED_BYTE, 0, divisor.length); 1494 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1495 }, (res) => { 1496 console.info("webgltest", res); 1497 expect(res[0]).assertEqual(255); 1498 expect(res[1]).assertEqual(0); 1499 expect(res[2]).assertEqual(0); 1500 expect(res[3]).assertEqual(255); 1501 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1502 }); 1503 done(); 1504 }); 1505 /** 1506 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0054 1507 * @tc.name webgl2_test_drawElementsInstanced_1 1508 * @tc.desc Test drawElementsInstanced. 1509 */ 1510 it('webgl2_test_drawElementsInstanced_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1511 async function (done) { 1512 console.info("webgl2test [webgl2_test_drawElementsInstanced_1] drawElementsInstanced"); 1513 drawElementsInstanced((indices, divisor) => { 1514 gl.drawElementsInstanced(gl.LINE_STRIP, indices.length, gl.UNSIGNED_BYTE, 0, divisor.length); 1515 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1516 }, (res) => { 1517 console.info("webgltest", res); 1518 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1519 }); 1520 done(); 1521 }); 1522 /** 1523 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0055 1524 * @tc.name webgl2_test_drawElementsInstanced_3 1525 * @tc.desc Test drawElementsInstanced. 1526 */ 1527 it('webgl2_test_drawElementsInstanced_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1528 async function (done) { 1529 console.info("webgl2test [webgl2_test_drawElementsInstanced_3] drawElementsInstanced"); 1530 drawElementsInstanced((indices, divisor) => { 1531 gl.drawElementsInstanced(gl.LINES, indices.length, gl.UNSIGNED_BYTE, 0, divisor.length); 1532 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1533 }, (res) => { 1534 console.info("webgltest", res); 1535 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1536 }); 1537 done(); 1538 }); 1539 /** 1540 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0056 1541 * @tc.name webgl2_test_drawElementsInstanced_4 1542 * @tc.desc Test drawElementsInstanced. 1543 */ 1544 it('webgl2_test_drawElementsInstanced_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1545 async function (done) { 1546 console.info("webgl2test [webgl2_test_drawElementsInstanced_4] drawElementsInstanced"); 1547 drawElementsInstanced((indices, divisor) => { 1548 gl.drawElementsInstanced(gl.TRIANGLE_STRIP, indices.length, gl.UNSIGNED_BYTE, 0, divisor.length); 1549 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1550 }, (res) => { 1551 console.info("webgltest", res); 1552 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1553 }); 1554 done(); 1555 }); 1556 /** 1557 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0057 1558 * @tc.name webgl2_test_drawElementsInstanced_5 1559 * @tc.desc Test drawElementsInstanced. 1560 */ 1561 it('webgl2_test_drawElementsInstanced_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1562 async function (done) { 1563 console.info("webgl2test [webgl2_test_drawElementsInstanced_5] drawElementsInstanced"); 1564 drawElementsInstanced((indices, divisor) => { 1565 gl.drawElementsInstanced(gl.TRIANGLE_FAN, indices.length, gl.UNSIGNED_BYTE, 0, divisor.length); 1566 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1567 }, (res) => { 1568 console.info("webgltest", res); 1569 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1570 }); 1571 done(); 1572 }); 1573 function drawRangeElements(callback, finish) { 1574 let p = createProgram(gl, `#version 300 es 1575 layout(location=0) in vec4 a_position; 1576 layout(location=1) in vec4 a_color; 1577 out vec4 v_color; 1578 void main(){ 1579 gl_Position = a_position; 1580 gl_PointSize = 10.0; 1581 v_color = a_color; 1582 } 1583 `, `#version 300 es 1584 precision mediump float; 1585 in vec4 v_color; 1586 out vec4 color; 1587 void main(){ 1588 color = v_color; 1589 } 1590 `); 1591 let source = new Float32Array([ 1592 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1593 -1.0, -1.0, 0.0, 1.0, 0.0, 1.0, 1594 1.0, -1.0, 0.0, 1.0, 0.0, 1.0, 1595 -1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1596 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1597 ]); 1598 let indices = new Uint16Array([ 1599 0, 1, 2, 1600 0, 1, 3, 1601 0, 3, 4, 1602 0, 2, 4, 1603 ]); 1604 let buffer = gl.createBuffer(); 1605 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); 1606 gl.bufferData(gl.ARRAY_BUFFER, source, gl.STATIC_DRAW, 0, source.length); 1607 let indexBuffer = gl.createBuffer(); 1608 gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer); 1609 gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW, 0, indices.length); 1610 gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 6 * 4, 0); 1611 gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 6 * 4, 2 * 4); 1612 gl.enableVertexAttribArray(0); 1613 gl.enableVertexAttribArray(1); 1614 gl.clearColor(1.0, 1.0, 1.0, 1.0); 1615 gl.clear(gl.COLOR_BUFFER_BIT); 1616 callback(); 1617 let res = new Uint8Array(2 * 2 * 4); 1618 gl.readPixels(0, 0, 2, 2, gl.RGBA, gl.UNSIGNED_BYTE, res); 1619 console.log("drawRangeElements=>", res); 1620 finish(res); 1621 gl.flush(); 1622 } 1623 /** 1624 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0058 1625 * @tc.name webgl2_test_drawRangeElements 1626 * @tc.desc Test drawRangeElements. 1627 */ 1628 it('webgl2_test_drawRangeElements', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1629 console.info("webgl2test [webgl2_test_drawRangeElements] drawRangeElements"); 1630 drawRangeElements(() => { 1631 gl.drawRangeElements(gl.TRIANGLES, 0, 5, 6, gl.UNSIGNED_SHORT, 0 * 2); 1632 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1633 }, (res) => { 1634 expect(res[0]).assertEqual(0); 1635 expect(res[1]).assertEqual(255); 1636 expect(res[2]).assertEqual(0); 1637 expect(res[3]).assertEqual(255); 1638 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1639 }); 1640 done(); 1641 }); 1642 /** 1643 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0059 1644 * @tc.name webgl2_test_drawRangeElements_1 1645 * @tc.desc Test drawRangeElements. 1646 */ 1647 it('webgl2_test_drawRangeElements_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1648 async function (done) { 1649 console.info("webgl2test [webgl2_test_drawRangeElements_1] drawRangeElements"); 1650 drawRangeElements(() => { 1651 gl.drawRangeElements(gl.POINTS, 0, 2, 6, gl.UNSIGNED_SHORT, 0 * 2); 1652 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1653 }, (res) => { 1654 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1655 }); 1656 done(); 1657 }); 1658 /** 1659 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0060 1660 * @tc.name webgl2_test_drawRangeElements_2 1661 * @tc.desc Test drawRangeElements. 1662 */ 1663 it('webgl2_test_drawRangeElements_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1664 async function (done) { 1665 console.info("webgl2test [webgl2_test_drawRangeElements_2] drawRangeElements"); 1666 drawRangeElements(() => { 1667 gl.drawRangeElements(gl.LINE_STRIP, 0, 2, 6, gl.UNSIGNED_SHORT, 0 * 2); 1668 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1669 }, (res) => { 1670 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1671 }); 1672 done(); 1673 }); 1674 /** 1675 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0061 1676 * @tc.name webgl2_test_drawRangeElements_3 1677 * @tc.desc Test drawRangeElements. 1678 */ 1679 it('webgl2_test_drawRangeElements_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1680 async function (done) { 1681 console.info("webgl2test [webgl2_test_drawRangeElements_3] drawRangeElements"); 1682 drawRangeElements(() => { 1683 gl.drawRangeElements(gl.LINE_LOOP, 0, 2, 6, gl.UNSIGNED_SHORT, 0 * 2); 1684 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1685 }, (res) => { 1686 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1687 }); 1688 done(); 1689 }); 1690 /** 1691 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0062 1692 * @tc.name webgl2_test_drawRangeElements_4 1693 * @tc.desc Test drawRangeElements. 1694 */ 1695 it('webgl2_test_drawRangeElements_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1696 async function (done) { 1697 console.info("webgl2test [webgl2_test_drawRangeElements_4] drawRangeElements"); 1698 drawRangeElements(() => { 1699 gl.drawRangeElements(gl.LINES, 0, 2, 6, gl.UNSIGNED_SHORT, 0 * 2); 1700 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1701 }, (res) => { 1702 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1703 }); 1704 done(); 1705 }); 1706 /** 1707 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0063 1708 * @tc.name webgl2_test_drawRangeElements_5 1709 * @tc.desc Test drawRangeElements. 1710 */ 1711 it('webgl2_test_drawRangeElements_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1712 async function (done) { 1713 console.info("webgl2test [webgl2_test_drawRangeElements_5] drawRangeElements"); 1714 drawRangeElements(() => { 1715 gl.drawRangeElements(gl.TRIANGLE_STRIP, 0, 2, 6, gl.UNSIGNED_SHORT, 0 * 2); 1716 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1717 }, (res) => { 1718 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1719 }); 1720 done(); 1721 }); 1722 /** 1723 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0064 1724 * @tc.name webgl2_test_drawRangeElements_6 1725 * @tc.desc Test drawRangeElements. 1726 */ 1727 it('webgl2_test_drawRangeElements_6', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1728 async function (done) { 1729 console.info("webgl2test [webgl2_test_drawRangeElements_6] drawRangeElements"); 1730 drawRangeElements(() => { 1731 gl.drawRangeElements(gl.TRIANGLE_FAN, 0, 2, 6, gl.UNSIGNED_SHORT, 0 * 2); 1732 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1733 }, (res) => { 1734 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1735 }); 1736 done(); 1737 }); 1738 function drawBuffers(callback, finish) { 1739 let srcViewport = gl.getParameter(gl.VIEWPORT); 1740 let p = createProgram(gl, `#version 300 es 1741 void main() { 1742 gl_PointSize = 300.0; 1743 gl_Position = vec4(0, 0, 0, 1); 1744 } 1745 `, `#version 300 es 1746 precision mediump float; 1747 layout(location = 0) out vec4 outColor0; 1748 layout(location = 1) out vec4 outColor1; 1749 layout(location = 2) out vec4 outColor2; 1750 void main() { 1751 outColor0 = vec4(1.0, 0.0, 0.0, 1.0); 1752 outColor1 = vec4(0.0, 1.0, 0.0, 1.0); 1753 outColor2 = vec4(0.0, 0.0, 1.0, 1.0); 1754 } 1755 `); 1756 let fb = gl.createFramebuffer(); 1757 gl.bindFramebuffer(gl.FRAMEBUFFER, fb); 1758 let textures = []; 1759 for (let i = 0; i < 3; i++) { 1760 let texture = gl.createTexture(); 1761 textures.push(texture); 1762 gl.bindTexture(gl.TEXTURE_2D, texture); 1763 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); 1764 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.TEXTURE_2D, texture, 0); 1765 } 1766 callback(); 1767 gl.viewport(0, 0, 1, 1); 1768 gl.drawArrays(gl.POINTS, 0, 1); 1769 let result = new Uint8Array(1 * 1 * 4); 1770 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, result); 1771 console.info("webgltest ", result); 1772 finish(result); 1773 textures.forEach((it) => gl.deleteTexture(it)); 1774 gl.viewport(srcViewport[0], srcViewport[1], srcViewport[2], srcViewport[3]); 1775 gl.bindFramebuffer(gl.FRAMEBUFFER, null); 1776 gl.deleteFramebuffer(fb); 1777 gl.deleteShader(p.vertexShader); 1778 gl.deleteShader(p.fragmentShader); 1779 gl.deleteProgram(p.program); 1780 gl.flush(); 1781 } 1782 /** 1783 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0065 1784 * @tc.name webgl2_test_drawBuffers 1785 * @tc.desc Test drawBuffers. 1786 */ 1787 it('webgl2_test_drawBuffers', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1788 console.info("webgl2test [webgl2_test_drawBuffers] drawBuffers"); 1789 drawBuffers(() => { 1790 gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]); 1791 gl.readBuffer(gl.COLOR_ATTACHMENT0); 1792 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1793 }, (result) => { 1794 expect(result[0]).assertEqual(255); 1795 expect(result[1]).assertEqual(0); 1796 expect(result[2]).assertEqual(0); 1797 expect(result[3]).assertEqual(255); 1798 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1799 }); 1800 done(); 1801 }); 1802 /** 1803 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0066 1804 * @tc.name webgl2_test_drawBuffers_1 1805 * @tc.desc Test drawBuffers. 1806 */ 1807 it('webgl2_test_drawBuffers_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1808 console.info("webgl2test [webgl2_test_drawBuffers_1] drawBuffers"); 1809 drawBuffers(() => { 1810 gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]); 1811 gl.readBuffer(gl.NONE); 1812 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1813 }, (result) => { 1814 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 1815 }); 1816 done(); 1817 }); 1818 /** 1819 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0067 1820 * @tc.name webgl2_test_drawBuffers_2 1821 * @tc.desc Test drawBuffers. 1822 */ 1823 it('webgl2_test_drawBuffers_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1824 console.info("webgl2test [webgl2_test_drawBuffers_2] drawBuffers"); 1825 drawBuffers(() => { 1826 gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]); 1827 gl.readBuffer(gl.BACK); 1828 }, (result) => { 1829 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 1830 }); 1831 done(); 1832 }); 1833 /** 1834 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0068 1835 * @tc.name webgl2_test_drawBuffers_3 1836 * @tc.desc Test drawBuffers. 1837 */ 1838 it('webgl2_test_drawBuffers_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1839 console.info("webgl2test [webgl2_test_drawBuffers_3] drawBuffers"); 1840 drawBuffers(() => { 1841 gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]); 1842 gl.readBuffer(gl.COLOR_ATTACHMENT1); 1843 }, (result) => { 1844 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1845 }); 1846 done(); 1847 }); 1848 /** 1849 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0069 1850 * @tc.name webgl2_test_drawBuffers_4 1851 * @tc.desc Test drawBuffers. 1852 */ 1853 it('webgl2_test_drawBuffers_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1854 console.info("webgl2test [webgl2_test_drawBuffers_4] drawBuffers"); 1855 drawBuffers(() => { 1856 gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]); 1857 gl.readBuffer(gl.COLOR_ATTACHMENT2); 1858 }, (result) => { 1859 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1860 }); 1861 done(); 1862 }); 1863 /** 1864 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0070 1865 * @tc.name webgl2_test_drawBuffers_5 1866 * @tc.desc Test drawBuffers. 1867 */ 1868 it('webgl2_test_drawBuffers_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1869 console.info("webgl2test [webgl2_test_drawBuffers_5] drawBuffers"); 1870 drawBuffers(() => { 1871 gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]); 1872 gl.readBuffer(gl.COLOR_ATTACHMENT3); 1873 }, (result) => { 1874 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 1875 }); 1876 done(); 1877 }); 1878 function clearBufferfv(callback, finish) { 1879 let p = createProgram(gl, `#version 300 es 1880 void main(){ 1881 gl_Position = vec4(0.0,0.0,0.0,1.0); 1882 gl_PointSize= 100.0; 1883 } 1884 `, `#version 300 es 1885 precision mediump float; 1886 out vec4 color; 1887 void main(){ 1888 color = vec4(1.0,0.0,0.0,1.0); 1889 } 1890 `); 1891 callback(); 1892 gl.drawArrays(gl.POINTS, 0, 1); 1893 let result = new Uint8Array(1 * 1 * 4); 1894 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, result); 1895 console.info("webgltest ", result); 1896 finish(result); 1897 gl.deleteShader(p.vertexShader); 1898 gl.deleteShader(p.fragmentShader); 1899 gl.deleteProgram(p.program); 1900 gl.flush(); 1901 } 1902 /** 1903 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0071 1904 * @tc.name webgl2_test_clearBufferfv 1905 * @tc.desc Test clearBufferfv. 1906 */ 1907 it('webgl2_test_clearBufferfv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1908 console.info("webgl2test [webgl2_test_clearBufferfv] clearBufferfv"); 1909 clearBufferfv(() => { 1910 gl.clearBufferfv(gl.COLOR, 0, new Float32Array([0.0, 0.0, 1.0, 1.0])); 1911 }, (result) => { 1912 expect(result[0]).assertEqual(0); 1913 expect(result[1]).assertEqual(0); 1914 expect(result[2]).assertEqual(255); 1915 expect(result[3]).assertEqual(255); 1916 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1917 }); 1918 done(); 1919 }); 1920 /** 1921 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0072 1922 * @tc.name webgl2_test_clearBufferfv_1 1923 * @tc.desc Test clearBufferfv. 1924 */ 1925 it('webgl2_test_clearBufferfv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1926 console.info("webgl2test [webgl2_test_clearBufferfv_1] clearBufferfv"); 1927 clearBufferfv(() => { 1928 gl.clearBufferfv(gl.DEPTH, 0, new Float32Array([0.0, 0.0, 1.0, 1.0])); 1929 }, (result) => { 1930 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1931 }); 1932 done(); 1933 }); 1934 /** 1935 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0073 1936 * @tc.name webgl2_test_clearBufferfv_2 1937 * @tc.desc Test clearBufferfv. 1938 */ 1939 it('webgl2_test_clearBufferfv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1940 console.info("webgl2test [webgl2_test_clearBufferfv_2] clearBufferfv"); 1941 clearBufferfv(() => { 1942 gl.clearBufferfv(gl.STENCIL, 0, new Float32Array([0.0, 0.0, 1.0, 1.0])); 1943 }, (result) => { 1944 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 1945 }); 1946 done(); 1947 }); 1948 /** 1949 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0074 1950 * @tc.name webgl2_test_clearBufferfv_3 1951 * @tc.desc Test clearBufferfv. 1952 */ 1953 it('webgl2_test_clearBufferfv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1954 console.info("webgl2test [webgl2_test_clearBufferfv_3] clearBufferfv"); 1955 clearBufferfv(() => { 1956 gl.clearBufferfv(gl.DEPTH_STENCIL, 0, new Float32Array([0.0, 0.0, 1.0, 1.0])); 1957 }, (result) => { 1958 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 1959 }); 1960 done(); 1961 }); 1962 function clearBufferiv(callback, finish) { 1963 let p = createProgram(gl, `#version 300 es 1964 void main(){ 1965 gl_Position = vec4(0.0,0.0,0.0,1.0); 1966 gl_PointSize= 100.0; 1967 } 1968 `, `#version 300 es 1969 precision mediump float; 1970 out vec4 color; 1971 void main(){ 1972 color = vec4(1.0,0.0,0.0,1.0); 1973 } 1974 `); 1975 let framebuffer = gl.createFramebuffer(); 1976 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 1977 // Creates and binds a render buffer object as a color attachment 1978 const colorRenderbuffer = gl.createRenderbuffer(); 1979 gl.bindRenderbuffer(gl.RENDERBUFFER, colorRenderbuffer); 1980 gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA8I, 100, 100); 1981 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, colorRenderbuffer); 1982 callback(); 1983 let result = new Int32Array(100 * 100 * 4); 1984 gl.readPixels(0, 0, 100, 100, gl.RGBA_INTEGER, gl.INT, result); 1985 console.info("webgltest ", result); 1986 finish(result); 1987 gl.bindRenderbuffer(gl.RENDERBUFFER, null); 1988 gl.bindFramebuffer(gl.FRAMEBUFFER, null); 1989 gl.deleteFramebuffer(framebuffer); 1990 gl.deleteRenderbuffer(colorRenderbuffer); 1991 gl.deleteShader(p.vertexShader); 1992 gl.deleteShader(p.fragmentShader); 1993 gl.deleteProgram(p.program); 1994 gl.flush(); 1995 } 1996 /** 1997 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0075 1998 * @tc.name webgl2_test_clearBufferiv 1999 * @tc.desc Test clearBufferiv. 2000 */ 2001 it('webgl2_test_clearBufferiv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2002 console.info("webgl2test [webgl2_test_clearBufferiv] clearBufferiv"); 2003 clearBufferiv(() => { 2004 gl.clearBufferiv(gl.COLOR, 0, new Int32Array([0, 0, 127, 127])); 2005 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2006 }, (result) => { 2007 expect(result[0]).assertEqual(0); 2008 expect(result[1]).assertEqual(0); 2009 expect(result[2]).assertEqual(127); 2010 expect(result[3]).assertEqual(127); 2011 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2012 }); 2013 done(); 2014 }); 2015 /** 2016 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0076 2017 * @tc.name webgl2_test_clearBufferiv_1 2018 * @tc.desc Test clearBufferiv. 2019 */ 2020 it('webgl2_test_clearBufferiv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2021 console.info("webgl2test [webgl2_test_clearBufferiv_1] clearBufferiv"); 2022 clearBufferiv(() => { 2023 gl.clearBufferiv(gl.DEPTH, 0, new Int32Array([0, 0, 127, 127])); 2024 }, (result) => { 2025 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 2026 }); 2027 done(); 2028 }); 2029 /** 2030 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0077 2031 * @tc.name webgl2_test_clearBufferiv_2 2032 * @tc.desc Test clearBufferiv. 2033 */ 2034 it('webgl2_test_clearBufferiv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2035 console.info("webgl2test [webgl2_test_clearBufferiv_2] clearBufferiv"); 2036 clearBufferiv(() => { 2037 gl.clearBufferiv(gl.STENCIL, 0, new Int32Array([0, 0, 127, 127])); 2038 }, (result) => { 2039 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2040 }); 2041 done(); 2042 }); 2043 function clearBufferuiv(callback, finish) { 2044 let p = createProgram(gl, `#version 300 es 2045 void main(){ 2046 gl_Position = vec4(0.0,0.0,0.0,1.0); 2047 gl_PointSize= 100.0; 2048 } 2049 `, `#version 300 es 2050 precision mediump float; 2051 out vec4 color; 2052 void main(){ 2053 color = vec4(1.0,0.0,0.0,1.0); 2054 } 2055 `); 2056 let framebuffer = gl.createFramebuffer(); 2057 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 2058 // Creates and binds a render buffer object as a color attachment 2059 const colorRenderbuffer = gl.createRenderbuffer(); 2060 gl.bindRenderbuffer(gl.RENDERBUFFER, colorRenderbuffer); 2061 gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA8UI, 1, 1); 2062 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, colorRenderbuffer); 2063 callback(); 2064 let result = new Uint32Array(1 * 1 * 4); 2065 gl.readPixels(0, 0, 1, 1, gl.RGBA_INTEGER, gl.UNSIGNED_INT, result); 2066 console.info("webgltest ", result); 2067 finish(result); 2068 gl.bindRenderbuffer(gl.RENDERBUFFER, null); 2069 gl.bindFramebuffer(gl.FRAMEBUFFER, null); 2070 gl.deleteFramebuffer(framebuffer); 2071 gl.deleteRenderbuffer(colorRenderbuffer); 2072 gl.deleteShader(p.vertexShader); 2073 gl.deleteShader(p.fragmentShader); 2074 gl.deleteProgram(p.program); 2075 } 2076 /** 2077 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0078 2078 * @tc.name webgl2_test_clearBufferuiv 2079 * @tc.desc Test clearBufferuiv. 2080 */ 2081 it('webgl2_test_clearBufferuiv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2082 console.info("webgl2test [webgl2_test_clearBufferuiv] clearBufferuiv"); 2083 clearBufferuiv(() => { 2084 gl.clearBufferuiv(gl.COLOR, 0, new Uint32Array([255, 255, 255, 255])); 2085 }, (res) => { 2086 expect(res[0]).assertEqual(255); 2087 expect(res[1]).assertEqual(255); 2088 expect(res[2]).assertEqual(255); 2089 expect(res[3]).assertEqual(255); 2090 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2091 }); 2092 done(); 2093 }); 2094 /** 2095 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0079 2096 * @tc.name webgl2_test_clearBufferuiv_1 2097 * @tc.desc Test clearBufferuiv. 2098 */ 2099 it('webgl2_test_clearBufferuiv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2100 console.info("webgl2test [webgl2_test_clearBufferuiv_1] clearBufferuiv"); 2101 clearBufferuiv(() => { 2102 gl.clearBufferuiv(gl.DEPTH, 0, new Uint32Array([255, 255, 255, 255])); 2103 }, (res) => { 2104 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 2105 }); 2106 done(); 2107 }); 2108 /** 2109 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0080 2110 * @tc.name webgl2_test_clearBufferuiv_2 2111 * @tc.desc Test clearBufferuiv. 2112 */ 2113 it('webgl2_test_clearBufferuiv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2114 console.info("webgl2test [webgl2_test_clearBufferuiv_2] clearBufferuiv"); 2115 clearBufferuiv(() => { 2116 gl.clearBufferuiv(gl.STENCIL, 0, new Uint32Array([255, 255, 255, 255])); 2117 }, (res) => { 2118 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 2119 }); 2120 done(); 2121 }); 2122 /** 2123 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0081 2124 * @tc.name webgl2_test_clearBufferuiv_3 2125 * @tc.desc Test clearBufferuiv. 2126 */ 2127 it('webgl2_test_clearBufferuiv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2128 console.info("webgl2test [webgl2_test_clearBufferuiv_3] clearBufferuiv"); 2129 clearBufferuiv(() => { 2130 gl.clearBufferuiv(gl.DEPTH_STENCIL, 0, new Uint32Array([255, 255, 255, 255])); 2131 }, (res) => { 2132 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 2133 }); 2134 done(); 2135 }); 2136 function clearBufferfi(callback, finish) { 2137 let p = createProgram(gl, `#version 300 es 2138 layout(location=0)in vec4 a_position; 2139 layout(location=1)in vec3 a_color; 2140 out vec3 v_color; 2141 void main(){ 2142 gl_Position = a_position; 2143 gl_PointSize= 100.0; 2144 v_color = a_color; 2145 } 2146 `, `#version 300 es 2147 precision mediump float; 2148 in vec3 v_color; 2149 out vec4 color; 2150 void main(){ 2151 color = vec4(v_color,1.0); 2152 } 2153 `); 2154 let arr = new Float32Array([ 2155 1.0, 1.0, 0.1, 1.0, 0.0, 1.0, 2156 -1.0, 1.0, 0.1, 1.0, 0.0, 1.0, 2157 -1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 2158 1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 2159 ]); 2160 let buffer = gl.createBuffer(); 2161 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); 2162 gl.bufferData(gl.ARRAY_BUFFER, arr, gl.STATIC_DRAW, 0, arr.length); 2163 let indexBuffer = gl.createBuffer(); 2164 gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 6 * 4, 0); 2165 gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 6 * 4, 3 * 4); 2166 gl.enableVertexAttribArray(0); 2167 gl.enableVertexAttribArray(1); 2168 gl.enable(gl.DEPTH_TEST); 2169 gl.enable(gl.POLYGON_OFFSET_FILL); 2170 gl.polygonOffset(0.1, .1); 2171 gl.clearColor(0.0, 0.0, 1.0, 1.0); 2172 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT); 2173 callback(); 2174 gl.drawArrays(gl.TRIANGLE_FAN, 0, 4); 2175 gl.flush(); 2176 let result = new Uint8Array(1 * 1 * 4); 2177 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, result); 2178 console.info("webgltest ", result); 2179 finish(result); 2180 gl.deleteShader(p.vertexShader); 2181 gl.deleteShader(p.fragmentShader); 2182 gl.deleteProgram(p.program); 2183 gl.disable(gl.DEPTH_TEST); 2184 gl.flush(); 2185 } 2186 /** 2187 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0082 2188 * @tc.name webgl2_test_clearBufferfi 2189 * @tc.desc Test clearBufferfi. 2190 */ 2191 it('webgl2_test_clearBufferfi', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2192 console.info("webgl2test [webgl2_test_clearBufferfi] clearBufferfi"); 2193 clearBufferfi(() => { 2194 gl.clearBufferfi(gl.DEPTH_STENCIL, 0, 0.6, 0); 2195 }, (res) => { 2196 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2197 }); 2198 done(); 2199 }); 2200 /** 2201 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0083 2202 * @tc.name webgl2_test_clearBufferfi_1 2203 * @tc.desc Test clearBufferfi. 2204 */ 2205 it('webgl2_test_clearBufferfi_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2206 console.info("webgl2test [webgl2_test_clearBufferfi_1] clearBufferfi"); 2207 clearBufferfi(() => { 2208 gl.clearBufferfi(gl.COLOR, 0, 0.6, 0); 2209 }, (res) => { 2210 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 2211 }); 2212 done(); 2213 }); 2214 /** 2215 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0084 2216 * @tc.name webgl2_test_clearBufferfi_2 2217 * @tc.desc Test clearBufferfi. 2218 */ 2219 it('webgl2_test_clearBufferfi_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2220 console.info("webgl2test [webgl2_test_clearBufferfi_2] clearBufferfi"); 2221 clearBufferfi(() => { 2222 gl.clearBufferfi(gl.DEPTH, 0, 0.6, 0); 2223 }, (res) => { 2224 expect(checkError(gl)).assertEqual(gl.INVALID_ENUM); 2225 }); 2226 done(); 2227 }); 2228 /** 2229 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0085 2230 * @tc.name webgl2_test_clearBufferfi_3 2231 * @tc.desc Test clearBufferfi. 2232 */ 2233 it('webgl2_test_clearBufferfi_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2234 console.info("webgl2test [webgl2_test_clearBufferfi_2] clearBufferfi"); 2235 clearBufferfi(() => { 2236 gl.clearBufferfi(gl.DEPTH_STENCIL, 0, 0.6, 0); 2237 }, (res) => { 2238 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2239 }); 2240 done(); 2241 }); 2242 function bindBufferBase(callback, finish) { 2243 const uniformBuffer = gl.createBuffer(); 2244 gl.bindBuffer(gl.UNIFORM_BUFFER, uniformBuffer); 2245 gl.bufferData(gl.UNIFORM_BUFFER, new Float32Array([1.0, 2.0, 3.0]), gl.STATIC_DRAW); 2246 callback(uniformBuffer); 2247 const boundBuffer = gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 0); 2248 console.info('webgltest', boundBuffer); 2249 finish(boundBuffer, uniformBuffer); 2250 gl.deleteBuffer(uniformBuffer); 2251 } 2252 /** 2253 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0086 2254 * @tc.name webgl2_test_bindBufferBase 2255 * @tc.desc Test bindBufferBase. 2256 */ 2257 it('webgl2_test_bindBufferBase', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2258 console.info("webgl2test [webgl2_test_bindBufferBase] bindBufferBase"); 2259 const uniformBuffer = gl.createBuffer(); 2260 gl.bindBuffer(gl.UNIFORM_BUFFER, uniformBuffer); 2261 gl.bufferData(gl.UNIFORM_BUFFER, new Float32Array([1.0, 2.0, 3.0]), gl.STATIC_DRAW); 2262 gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, uniformBuffer); 2263 const boundBuffer = gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 0); 2264 console.info('webgltest', boundBuffer); 2265 expect(boundBuffer).assertEqual(uniformBuffer); 2266 gl.deleteBuffer(uniformBuffer); 2267 done(); 2268 }); 2269 /** 2270 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0087 2271 * @tc.name webgl2_test_bindBufferBase_1 2272 * @tc.desc Test bindBufferBase. 2273 */ 2274 it('webgl2_test_bindBufferBase_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2275 console.info("webgl2test [webgl2_test_bindBufferBase_1] bindBufferBase"); 2276 bindBufferBase((uniformBuffer) => { 2277 gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, uniformBuffer); 2278 }, (boundBuffer, uniformBuffer) => { 2279 expect(boundBuffer === uniformBuffer).assertEqual(false); 2280 }); 2281 done(); 2282 }); 2283 /** 2284 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0088 2285 * @tc.name webgl2_test_bindBufferBase_2 2286 * @tc.desc Test bindBufferBase. 2287 */ 2288 it('webgl2_test_bindBufferBase_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2289 console.info("webgl2test [webgl2_test_bindBufferBase_2] bindBufferBase"); 2290 bindBufferBase((uniformBuffer) => { 2291 gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, uniformBuffer); 2292 }, (boundBuffer, uniformBuffer) => { 2293 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2294 }); 2295 done(); 2296 }); 2297 function bindBufferRange(callback, finish) { 2298 console.info("webgl2test [webgl2_test_bindBufferRange] bindBufferRange"); 2299 const uniformBuffer = gl.createBuffer(); 2300 gl.bindBuffer(gl.UNIFORM_BUFFER, uniformBuffer); 2301 let float32Array = new Float32Array(256 * 4); 2302 gl.bufferData(gl.UNIFORM_BUFFER, float32Array, gl.STATIC_DRAW); 2303 const alignment = gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT); 2304 console.info("webgltest UNIFORM_BUFFER_OFFSET_ALIGNMENT", alignment); 2305 let offset = alignment * 2; 2306 callback(uniformBuffer, offset, float32Array); 2307 const boundBuffer = gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 0); 2308 finish(offset, float32Array); 2309 console.info('webgltest', boundBuffer); 2310 gl.deleteBuffer(uniformBuffer); 2311 } 2312 /** 2313 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0089 2314 * @tc.name webgl2_test_bindBufferRange 2315 * @tc.desc Test bindBufferRange. 2316 */ 2317 it('webgl2_test_bindBufferRange', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2318 console.info("webgl2test [webgl2_test_bindBufferRange] bindBufferRange"); 2319 const uniformBuffer = gl.createBuffer(); 2320 gl.bindBuffer(gl.UNIFORM_BUFFER, uniformBuffer); 2321 let float32Array = new Float32Array(256 * 4); 2322 gl.bufferData(gl.UNIFORM_BUFFER, float32Array, gl.STATIC_DRAW); 2323 const alignment = gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT); 2324 console.info("webgltest UNIFORM_BUFFER_OFFSET_ALIGNMENT", alignment); 2325 let offset = alignment * 2; 2326 gl.bindBufferRange(gl.UNIFORM_BUFFER, 0, uniformBuffer, offset, float32Array.length * float32Array.BYTES_PER_ELEMENT); 2327 const boundBuffer = gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 0); 2328 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_START, 0)).assertEqual(offset); 2329 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_SIZE, 0)).assertEqual(float32Array.length * float32Array.BYTES_PER_ELEMENT); 2330 console.info('webgltest', boundBuffer); 2331 expect(boundBuffer).assertEqual(uniformBuffer); 2332 gl.deleteBuffer(uniformBuffer); 2333 done(); 2334 }); 2335 /** 2336 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0090 2337 * @tc.name webgl2_test_bindBufferRange_1 2338 * @tc.desc Test bindBufferRange. 2339 */ 2340 it('webgl2_test_bindBufferRange_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2341 bindBufferRange((uniformBuffer, offset, float32Array) => { 2342 gl.bindBufferRange(gl.TRANSFORM_FEEDBACK_BUFFER, 0, uniformBuffer, offset, float32Array.length * float32Array.BYTES_PER_ELEMENT); 2343 }, (offset, float32Array) => { 2344 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_SIZE, 0)).assertEqual(0); 2345 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_START, 0)).assertEqual(0); 2346 }); 2347 done(); 2348 }); 2349 /** 2350 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0091 2351 * @tc.name webgl2_test_bindBufferRange_2 2352 * @tc.desc Test bindBufferRange. 2353 */ 2354 it('webgl2_test_bindBufferRange_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2355 bindBufferRange((uniformBuffer, offset, float32Array) => { 2356 gl.bindBufferRange(gl.TRANSFORM_FEEDBACK_BUFFER, 1, uniformBuffer, offset, float32Array.length * float32Array.BYTES_PER_ELEMENT); 2357 }, (offset, float32Array) => { 2358 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_SIZE, 0)).assertEqual(0); 2359 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_START, 0)).assertEqual(0); 2360 }); 2361 done(); 2362 }); 2363 /** 2364 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0092 2365 * @tc.name webgl2_test_getIndexedParameter 2366 * @tc.desc Test getIndexedParameter. 2367 */ 2368 it('webgl2_test_getIndexedParameter', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2369 async function (done) { 2370 console.info("webgl2test [webgl2_test_getIndexedParameter] getIndexedParameter"); 2371 const uniformBuffer = gl.createBuffer(); 2372 gl.bindBuffer(gl.UNIFORM_BUFFER, uniformBuffer); 2373 let float32Array = new Float32Array(256 * 4); 2374 gl.bufferData(gl.UNIFORM_BUFFER, float32Array, gl.STATIC_DRAW); 2375 const alignment = gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT); 2376 console.info("webgltest UNIFORM_BUFFER_OFFSET_ALIGNMENT", alignment); 2377 let offset = alignment * 2; 2378 gl.bindBufferRange(gl.UNIFORM_BUFFER, 0, uniformBuffer, offset, float32Array.length * float32Array.BYTES_PER_ELEMENT); 2379 const boundBuffer = gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 0); 2380 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_START, 0)).assertEqual(offset); 2381 expect(gl.getIndexedParameter(gl.UNIFORM_BUFFER_SIZE, 0)).assertEqual(float32Array.length * float32Array.BYTES_PER_ELEMENT); 2382 console.info('webgltest', boundBuffer); 2383 expect(boundBuffer).assertEqual(uniformBuffer); 2384 gl.deleteBuffer(uniformBuffer); 2385 done(); 2386 }); 2387 /** 2388 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0093 2389 * @tc.name webgl2_test_getUniformIndices 2390 * @tc.desc Test getUniformIndices. 2391 */ 2392 it('webgl2_test_getUniformIndices', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2393 console.info("webgl2test [webgl2_test_getUniformIndices] getUniformIndices"); 2394 let p = createProgram(gl, `#version 300 es 2395 uniform float u_size_1; 2396 uniform float u_size_2; 2397 void main(){ 2398 gl_Position = vec4(0.0,0.0,0.0,1.0); 2399 gl_PointSize = u_size_1 + u_size_2; 2400 } 2401 `, `#version 300 es 2402 precision mediump float; 2403 out vec4 color; 2404 void main(){ 2405 color = vec4(1.0,0.0,0.0,1.0); 2406 } 2407 `); 2408 let indices = [...gl.getUniformIndices(p.program, ['u_size_1', 'u_size_2', 'u_size_3'])]; 2409 console.info("webgltest", indices); 2410 expect(indices[0]).assertLargerOrEqual(0); 2411 expect(indices[1]).assertLargerOrEqual(0); 2412 expect(indices[2] !== 2).assertEqual(true); 2413 gl.deleteShader(p.vertexShader); 2414 gl.deleteShader(p.fragmentShader); 2415 gl.deleteProgram(p.program); 2416 done(); 2417 }); 2418 /** 2419 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0094 2420 * @tc.name webgl2_test_getActiveUniforms 2421 * @tc.desc Test getActiveUniforms. 2422 */ 2423 it('webgl2_test_getActiveUniforms', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2424 console.info("webgl2test [webgl2_test_getActiveUniforms] getActiveUniforms"); 2425 let p = createProgram(gl, `#version 300 es 2426 uniform float u_size_1; 2427 uniform float u_size_2; 2428 uniform float u_size_3; 2429 void main(){ 2430 gl_Position = vec4(0.0,0.0,0.0,1.0); 2431 gl_PointSize = u_size_1 + u_size_2 + u_size_3; 2432 } 2433 `, `#version 300 es 2434 precision mediump float; 2435 out vec4 color; 2436 void main(){ 2437 color = vec4(1.0,0.0,0.0,1.0); 2438 } 2439 `); 2440 const activeUniformsCount = gl.getProgramParameter(p.program, gl.ACTIVE_UNIFORMS); 2441 console.log(activeUniformsCount); 2442 let uniformIndices = gl.getUniformIndices(p.program, ['u_size_1', 'u_size_2', 'u_size_3']); 2443 const uniformOffsets = gl.getActiveUniforms(p.program, uniformIndices, gl.UNIFORM_TYPE); 2444 console.info("webgltest", uniformIndices, uniformOffsets); 2445 expect(uniformOffsets[0]).assertEqual(gl.FLOAT); 2446 expect(uniformOffsets[1]).assertEqual(gl.FLOAT); 2447 expect(uniformOffsets[2]).assertEqual(gl.FLOAT); 2448 gl.deleteShader(p.vertexShader); 2449 gl.deleteShader(p.fragmentShader); 2450 gl.deleteProgram(p.program); 2451 done(); 2452 }); 2453 /** 2454 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0095 2455 * @tc.name webgl2_test_getUniformBlockIndex 2456 * @tc.desc Test getUniformBlockIndex. 2457 */ 2458 it('webgl2_test_getUniformBlockIndex', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2459 async function (done) { 2460 console.info("webgl2test [webgl2_test_getUniformBlockIndex] getUniformBlockIndex"); 2461 let p = createProgram(gl, `#version 300 es 2462 uniform float u_size_1; 2463 uniform float u_size_2; 2464 uniform float u_size_3; 2465 uniform UBOData1 { 2466 mat4 u_matrix; 2467 } instanceName1; 2468 uniform UBOData2 { 2469 mat4 u_matrix; 2470 } instanceName2; 2471 void main(){ 2472 gl_Position = vec4(0.0,0.0,0.0,1.0); 2473 gl_PointSize = u_size_1 + u_size_2 + u_size_3; 2474 } 2475 `, `#version 300 es 2476 precision mediump float; 2477 out vec4 color; 2478 void main(){ 2479 color = vec4(1.0,0.0,0.0,1.0); 2480 } 2481 `); 2482 const blockIndex1 = gl.getUniformBlockIndex(p.program, "UBOData1"); 2483 const blockIndex2 = gl.getUniformBlockIndex(p.program, "UBOData2"); 2484 console.info("webgltest", blockIndex1, blockIndex2); 2485 expect(blockIndex1 >= 0).assertEqual(true); 2486 expect(blockIndex2 >= 0).assertEqual(true); 2487 gl.deleteShader(p.vertexShader); 2488 gl.deleteShader(p.fragmentShader); 2489 gl.deleteProgram(p.program); 2490 done(); 2491 }); 2492 /** 2493 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0096 2494 * @tc.name webgl2_test_getActiveUniformBlockParameter 2495 * @tc.desc Test getActiveUniformBlockParameter. 2496 */ 2497 it('webgl2_test_getActiveUniformBlockParameter', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2498 async function (done) { 2499 console.info("webgl2test [webgl2_test_getActiveUniformBlockParameter] getActiveUniformBlockParameter"); 2500 let p = createProgram(gl, `#version 300 es 2501 uniform float u_size_1; 2502 uniform float u_size_2; 2503 uniform float u_size_3; 2504 uniform UBOData1 { 2505 mat4 u_matrix1; 2506 mat4 u_matrix2; 2507 } instanceName1; 2508 uniform UBOData2 { 2509 mat4 u_matrix; 2510 } instanceName2; 2511 void main(){ 2512 gl_Position = vec4(0.0,0.0,0.0,1.0); 2513 gl_PointSize = u_size_1 + u_size_2 + u_size_3; 2514 } 2515 `, `#version 300 es 2516 precision mediump float; 2517 out vec4 color; 2518 void main(){ 2519 color = vec4(1.0,0.0,0.0,1.0); 2520 } 2521 `); 2522 let activeUniformBlocksCount = gl.getProgramParameter(p.program, gl.ACTIVE_UNIFORM_BLOCKS); 2523 console.log(activeUniformBlocksCount); 2524 const uniformBlockSize = gl.getActiveUniformBlockParameter(p.program, 0, gl.UNIFORM_BLOCK_DATA_SIZE); 2525 let uniformBlockActiveUniforms = gl.getActiveUniformBlockParameter(p.program, 0, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS); 2526 expect(uniformBlockSize >= 0).assertEqual(true); 2527 expect(uniformBlockActiveUniforms >= 0).assertEqual(true); 2528 gl.deleteShader(p.vertexShader); 2529 gl.deleteShader(p.fragmentShader); 2530 gl.deleteProgram(p.program); 2531 done(); 2532 }); 2533 /** 2534 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0097 2535 * @tc.name webgl2_test_getActiveUniformBlockName 2536 * @tc.desc Test getActiveUniformBlockName. 2537 */ 2538 it('webgl2_test_getActiveUniformBlockName', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2539 async function (done) { 2540 console.info("webgl2test [webgl2_test_getActiveUniformBlockName] getActiveUniformBlockNatexImage2Dme"); 2541 let p = createProgram(gl, `#version 300 es 2542 uniform float u_size_1; 2543 uniform float u_size_2; 2544 uniform float u_size_3; 2545 uniform UBOData1 { 2546 mat4 u_matrix1; 2547 mat4 u_matrix2; 2548 } instanceName1; 2549 uniform UBOData2 { 2550 mat4 u_matrix; 2551 } instanceName2; 2552 void main(){ 2553 gl_Position = vec4(0.0,0.0,0.0,1.0); 2554 gl_PointSize = u_size_1 + u_size_2 + u_size_3; 2555 } 2556 `, `#version 300 es 2557 precision mediump float; 2558 out vec4 color; 2559 void main(){ 2560 color = vec4(1.0,0.0,0.0,1.0); 2561 } 2562 `); 2563 let blockName1 = gl.getActiveUniformBlockName(p.program, 1); 2564 let blockName2 = gl.getActiveUniformBlockName(p.program, 0); 2565 console.info("webgltest", blockName1, blockName2); 2566 expect(blockName1).assertEqual("UBOData1"); 2567 expect(blockName2).assertEqual("UBOData2"); 2568 gl.deleteShader(p.vertexShader); 2569 gl.deleteShader(p.fragmentShader); 2570 gl.deleteProgram(p.program); 2571 done(); 2572 }); 2573 function uniformBlockBinding(callback, finish) { 2574 let p = createProgram(gl, `#version 300 es 2575 uniform float u_size_1; 2576 uniform float u_size_2; 2577 uniform float u_size_3; 2578 uniform UBOData1 { 2579 mat4 u_matrix1; 2580 mat4 u_matrix2; 2581 } instanceName1; 2582 uniform UBOData2 { 2583 mat4 u_matrix; 2584 } instanceName2; 2585 void main(){ 2586 gl_Position = vec4(0.0,0.0,0.0,1.0); 2587 gl_PointSize = u_size_1 + u_size_2 + u_size_3; 2588 } 2589 `, `#version 300 es 2590 precision mediump float; 2591 out vec4 color; 2592 void main(){ 2593 color = vec4(1.0,0.0,0.0,1.0); 2594 } 2595 `); 2596 const uniformBlockIndex = gl.getUniformBlockIndex(p.program, "UBOData1"); 2597 callback(uniformBlockIndex, p.program); 2598 const uniformBlockBinding = gl.getActiveUniformBlockParameter(p.program, uniformBlockIndex, gl.UNIFORM_BLOCK_BINDING); 2599 console.info("webgltest uniformBlockBinding: ", uniformBlockBinding); 2600 finish(uniformBlockBinding); 2601 gl.deleteShader(p.vertexShader); 2602 gl.deleteShader(p.fragmentShader); 2603 gl.deleteProgram(p.program); 2604 } 2605 /** 2606 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0098 2607 * @tc.name webgl2_test_uniformBlockBinding 2608 * @tc.desc Test uniformBlockBinding. 2609 */ 2610 it('webgl2_test_uniformBlockBinding', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2611 async function (done) { 2612 console.info("webgl2test [webgl2_test_uniformBlockBinding] uniformBlockBinding"); 2613 uniformBlockBinding((uniformBlockIndex, program) => { 2614 gl.uniformBlockBinding(program, uniformBlockIndex, 10); 2615 console.log(gl.getUniformBlockIndex(program, "UBOData1")); 2616 console.log(gl.getUniformBlockIndex(program, "UBOData2")); 2617 console.log(gl.getActiveUniformBlockParameter(program, gl.getUniformBlockIndex(program, "UBOData1"), gl.UNIFORM_BLOCK_BINDING)); 2618 console.log(gl.getActiveUniformBlockParameter(program, gl.getUniformBlockIndex(program, "UBOData2"), gl.UNIFORM_BLOCK_BINDING)); 2619 }, (res) => { 2620 expect(res).assertEqual(10); 2621 }); 2622 done(); 2623 }); 2624 /** 2625 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0099 2626 * @tc.name webgl2_test_uniformBlockBinding_1 2627 * @tc.desc Test uniformBlockBinding. 2628 */ 2629 it('webgl2_test_uniformBlockBinding_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2630 async function (done) { 2631 console.info("webgl2test [webgl2_test_uniformBlockBinding_1] uniformBlockBinding"); 2632 uniformBlockBinding((uniformBlockIndex, program) => { 2633 gl.uniformBlockBinding(program, 1, 10); 2634 }, (res) => { 2635 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2636 expect(res).assertLargerOrEqual(0); 2637 }); 2638 done(); 2639 }); 2640 /** 2641 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0100 2642 * @tc.name webgl2_test_uniformBlockBinding_2 2643 * @tc.desc Test uniformBlockBinding. 2644 */ 2645 it('webgl2_test_uniformBlockBinding_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2646 async function (done) { 2647 console.info("webgl2test [webgl2_test_uniformBlockBinding_2] uniformBlockBinding"); 2648 uniformBlockBinding((uniformBlockIndex, program) => { 2649 gl.uniformBlockBinding(program, -1, 10); 2650 }, (res) => { 2651 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2652 expect(res).assertEqual(0); 2653 }); 2654 done(); 2655 }); 2656 /** 2657 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0101 2658 * @tc.name webgl2_test_uniformBlockBinding_3 2659 * @tc.desc Test uniformBlockBinding. 2660 */ 2661 it('webgl2_test_uniformBlockBinding_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2662 async function (done) { 2663 console.info("webgl2test [webgl2_test_uniformBlockBinding_3] uniformBlockBinding"); 2664 uniformBlockBinding((uniformBlockIndex, program) => { 2665 gl.uniformBlockBinding(program, -1, -1); 2666 }, (res) => { 2667 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2668 expect(res).assertEqual(0); 2669 }); 2670 done(); 2671 }); 2672 /** 2673 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0102 2674 * @tc.name webgl2_test_uniformBlockBinding_4 2675 * @tc.desc Test uniformBlockBinding. 2676 */ 2677 it('webgl2_test_uniformBlockBinding_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2678 async function (done) { 2679 console.info("webgl2test [webgl2_test_uniformBlockBinding_4] uniformBlockBinding"); 2680 uniformBlockBinding((uniformBlockIndex, program) => { 2681 gl.uniformBlockBinding(program, 10, -1); 2682 }, (res) => { 2683 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2684 expect(res).assertEqual(0); 2685 }); 2686 done(); 2687 }); 2688 function bufferData(callback, finish) { 2689 let p = createProgram(gl, `#version 300 es 2690 in vec4 a_position; 2691 in vec3 a_color; 2692 out vec3 v_color; 2693 void main(){ 2694 gl_Position = a_position; 2695 gl_PointSize = 100.0; 2696 v_color = a_color; 2697 } 2698 `, `#version 300 es 2699 precision mediump float; 2700 in vec3 v_color; 2701 out vec4 color; 2702 void main(){ 2703 color = vec4(v_color,1.0); 2704 } 2705 `); 2706 let source = new Float32Array([ 2707 0, 0, 0, 0, 0, 2708 -1.0, -1.0, 1.0, 0.0, 0.0, 2709 -1.0, 1.0, 0.0, 1.0, 0.0, 2710 1.0, 1.0, 0.0, 0.0, 1.0, 2711 1.0, -1.0, 0.0, 0.0, 0.0, 2712 ]); 2713 let num = 4; 2714 let FSIZE = source.BYTES_PER_ELEMENT; 2715 let buffer = gl.createBuffer(); 2716 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); 2717 callback(source); 2718 let a_position = gl.getAttribLocation(p.program, 'a_position'); 2719 gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 5 * FSIZE, 0); 2720 gl.enableVertexAttribArray(a_position); 2721 let a_color = gl.getAttribLocation(p.program, 'a_color'); 2722 gl.vertexAttribPointer(a_color, 3, gl.FLOAT, false, 5 * FSIZE, 2 * FSIZE); 2723 gl.enableVertexAttribArray(a_color); 2724 gl.clearColor(0.8, 0.8, 0.8, 1.0); 2725 gl.clear(gl.COLOR_BUFFER_BIT); 2726 gl.drawArrays(gl.POINTS, 0, 1); 2727 let result = new Uint8Array(1 * 1 * 4); 2728 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, result); 2729 console.info("webgltest ", result); 2730 finish(result); 2731 gl.deleteBuffer(buffer); 2732 gl.deleteShader(p.vertexShader); 2733 gl.deleteShader(p.fragmentShader); 2734 gl.deleteProgram(p.program); 2735 gl.disableVertexAttribArray(a_color); 2736 gl.disableVertexAttribArray(a_position); 2737 gl.flush(); 2738 checkError(gl); 2739 } 2740 /** 2741 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0103 2742 * @tc.name webgl2_test_bufferData 2743 * @tc.desc Test bufferData. 2744 */ 2745 it('webgl2_test_bufferData', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2746 console.info("webgl2test [webgl2_test_bufferData] bufferData"); 2747 bufferData((source) => { 2748 gl.bufferData(gl.ARRAY_BUFFER, source, gl.STATIC_READ, 5, 5); 2749 }, (result) => { 2750 expect(result[0]).assertEqual(255); 2751 expect(result[1]).assertEqual(0); 2752 expect(result[2]).assertEqual(0); 2753 expect(result[3]).assertEqual(255); 2754 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2755 }); 2756 done(); 2757 }); 2758 /** 2759 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0104 2760 * @tc.name webgl2_test_bufferData_1 2761 * @tc.desc Test bufferData. 2762 */ 2763 it('webgl2_test_bufferData_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2764 console.info("webgl2test [webgl2_test_bufferData_1] bufferData"); 2765 bufferData((source) => { 2766 gl.bufferData(gl.COPY_READ_BUFFER, source, gl.STATIC_READ, 5, 5); 2767 }, (result) => { 2768 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2769 }); 2770 done(); 2771 }); 2772 /** 2773 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0105 2774 * @tc.name webgl2_test_bufferData_2 2775 * @tc.desc Test bufferData. 2776 */ 2777 it('webgl2_test_bufferData_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2778 console.info("webgl2test [webgl2_test_bufferData_2] bufferData"); 2779 bufferData((source) => { 2780 gl.bufferData(gl.COPY_WRITE_BUFFER, source, gl.STATIC_READ, 5, 5); 2781 }, (result) => { 2782 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2783 }); 2784 done(); 2785 }); 2786 /** 2787 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0106 2788 * @tc.name webgl2_test_bufferData_3 2789 * @tc.desc Test bufferData. 2790 */ 2791 it('webgl2_test_bufferData_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2792 console.info("webgl2test [webgl2_test_bufferData_3] bufferData"); 2793 bufferData((source) => { 2794 gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, source, gl.STATIC_READ, 5, 5); 2795 }, (result) => { 2796 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2797 }); 2798 done(); 2799 }); 2800 /** 2801 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0107 2802 * @tc.name webgl2_test_bufferData_4 2803 * @tc.desc Test bufferData. 2804 */ 2805 it('webgl2_test_bufferData_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2806 console.info("webgl2test [webgl2_test_bufferData_4] bufferData"); 2807 bufferData((source) => { 2808 gl.bufferData(gl.UNIFORM_BUFFER, source, gl.STATIC_READ, 5, 5); 2809 }, (result) => { 2810 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2811 }); 2812 done(); 2813 }); 2814 /** 2815 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0108 2816 * @tc.name webgl2_test_bufferData_5 2817 * @tc.desc Test bufferData. 2818 */ 2819 it('webgl2_test_bufferData_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2820 console.info("webgl2test [webgl2_test_bufferData_5] bufferData"); 2821 bufferData((source) => { 2822 gl.bufferData(gl.PIXEL_PACK_BUFFER, source, gl.STATIC_READ, 5, 5); 2823 }, (result) => { 2824 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2825 }); 2826 done(); 2827 }); 2828 /** 2829 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0109 2830 * @tc.name webgl2_test_bufferData_6 2831 * @tc.desc Test bufferData. 2832 */ 2833 it('webgl2_test_bufferData_6', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2834 console.info("webgl2test [webgl2_test_bufferData_6] bufferData"); 2835 bufferData((source) => { 2836 gl.bufferData(gl.PIXEL_UNPACK_BUFFER, source, gl.STATIC_READ, 5, 5); 2837 }, (result) => { 2838 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2839 }); 2840 done(); 2841 }); 2842 function bufferSubData(callback, finish) { 2843 let p = createProgram(gl, `#version 300 es 2844 in vec4 a_position; 2845 void main(){ 2846 gl_Position = a_position; 2847 } 2848 `, `#version 300 es 2849 precision mediump float; 2850 out vec4 color; 2851 void main(){ 2852 color = vec4(1.0,0.0,0.0,1.0); 2853 } 2854 `); 2855 // create vertex data 2856 const vertices = [ 2857 -0.5, -0.5, 0.0, 2858 0.5, -0.5, 0.0, 2859 -0.5, 0.5, 0.0 2860 ]; 2861 // create a buffer object and bind the data 2862 const vertexBuffer = gl.createBuffer(); 2863 gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); 2864 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW); 2865 const a_Position = gl.getAttribLocation(p.program, 'a_position'); 2866 gl.vertexAttribPointer(a_Position, 3, gl.FLOAT, false, 0, 0); 2867 gl.enableVertexAttribArray(a_Position); 2868 callback(); 2869 gl.clearColor(0.0, 0.0, 0.0, 1.0); 2870 gl.clear(gl.COLOR_BUFFER_BIT); 2871 gl.drawArrays(gl.TRIANGLES, 0, 3); 2872 let result = new Uint8Array(1 * 1 * 4); 2873 gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, result); 2874 console.info("webgltest ", result); 2875 finish(result); 2876 gl.disableVertexAttribArray(a_Position); 2877 gl.deleteBuffer(vertexBuffer); 2878 gl.deleteShader(p.vertexShader); 2879 gl.deleteShader(p.fragmentShader); 2880 gl.deleteProgram(p.program); 2881 gl.flush(); 2882 } 2883 /** 2884 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0110 2885 * @tc.name webgl2_test_bufferSubData 2886 * @tc.desc Test bufferSubData. 2887 */ 2888 it('webgl2_test_bufferSubData', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2889 console.info("webgl2test [webgl2_test_bufferSubData] bufferSubData"); 2890 bufferSubData(() => { 2891 gl.bufferSubData(gl.ARRAY_BUFFER, 0, new Float32Array([ 2892 -1.0, -1.0, 0.0, 2893 1.0, -1.0, 0.0, 2894 -1.0, 1.0, 0.0 2895 ])); 2896 }, (result) => { 2897 expect(result[0]).assertEqual(255); 2898 expect(result[1]).assertEqual(0); 2899 expect(result[2]).assertEqual(0); 2900 expect(result[3]).assertEqual(255); 2901 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2902 }); 2903 done(); 2904 }); 2905 /** 2906 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0111 2907 * @tc.name webgl2_test_bufferSubData_1 2908 * @tc.desc Test bufferSubData. 2909 */ 2910 it('webgl2_test_bufferSubData_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2911 console.info("webgl2test [webgl2_test_bufferSubData_1] bufferSubData"); 2912 bufferSubData(() => { 2913 gl.bufferSubData(gl.COPY_READ_BUFFER, 0, new Float32Array([ 2914 -1.0, -1.0, 0.0, 2915 1.0, -1.0, 0.0, 2916 -1.0, 1.0, 0.0 2917 ])); 2918 }, (result) => { 2919 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2920 }); 2921 done(); 2922 }); 2923 /** 2924 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0112 2925 * @tc.name webgl2_test_bufferSubData_2 2926 * @tc.desc Test bufferSubData. 2927 */ 2928 it('webgl2_test_bufferSubData_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2929 console.info("webgl2test [webgl2_test_bufferSubData_2] bufferSubData"); 2930 bufferSubData(() => { 2931 gl.bufferSubData(gl.COPY_WRITE_BUFFER, 0, new Float32Array([ 2932 -1.0, -1.0, 0.0, 2933 1.0, -1.0, 0.0, 2934 -1.0, 1.0, 0.0 2935 ])); 2936 }, (result) => { 2937 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2938 }); 2939 done(); 2940 }); 2941 /** 2942 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0113 2943 * @tc.name webgl2_test_bufferSubData_3 2944 * @tc.desc Test bufferSubData. 2945 */ 2946 it('webgl2_test_bufferSubData_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2947 console.info("webgl2test [webgl2_test_bufferSubData_3] bufferSubData"); 2948 bufferSubData(() => { 2949 gl.bufferSubData(gl.COPY_WRITE_BUFFER, 0, new Float32Array([ 2950 -1.0, -1.0, 0.0, 2951 1.0, -1.0, 0.0, 2952 -1.0, 1.0, 0.0 2953 ])); 2954 }, (result) => { 2955 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2956 }); 2957 done(); 2958 }); 2959 /** 2960 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0114 2961 * @tc.name webgl2_test_bufferSubData_4 2962 * @tc.desc Test bufferSubData. 2963 */ 2964 it('webgl2_test_bufferSubData_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2965 console.info("webgl2test [webgl2_test_bufferSubData_4] bufferSubData"); 2966 bufferSubData(() => { 2967 gl.bufferSubData(gl.TRANSFORM_FEEDBACK_BUFFER, 0, new Float32Array([ 2968 -1.0, -1.0, 0.0, 2969 1.0, -1.0, 0.0, 2970 -1.0, 1.0, 0.0 2971 ])); 2972 }, (result) => { 2973 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2974 }); 2975 done(); 2976 }); 2977 /** 2978 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0115 2979 * @tc.name webgl2_test_bufferSubData_5 2980 * @tc.desc Test bufferSubData. 2981 */ 2982 it('webgl2_test_bufferSubData_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2983 console.info("webgl2test [webgl2_test_bufferSubData_5] bufferSubData"); 2984 bufferSubData(() => { 2985 gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([ 2986 -1.0, -1.0, 0.0, 2987 1.0, -1.0, 0.0, 2988 -1.0, 1.0, 0.0 2989 ])); 2990 }, (result) => { 2991 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2992 }); 2993 done(); 2994 }); 2995 /** 2996 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0116 2997 * @tc.name webgl2_test_bufferSubData_6 2998 * @tc.desc Test bufferSubData. 2999 */ 3000 it('webgl2_test_bufferSubData_6', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 3001 console.info("webgl2test [webgl2_test_bufferSubData_6] bufferSubData"); 3002 bufferSubData(() => { 3003 gl.bufferSubData(gl.PIXEL_PACK_BUFFER, 0, new Float32Array([ 3004 -1.0, -1.0, 0.0, 3005 1.0, -1.0, 0.0, 3006 -1.0, 1.0, 0.0 3007 ])); 3008 }, (result) => { 3009 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 3010 }); 3011 done(); 3012 }); 3013 /** 3014 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_BUFFER_0117 3015 * @tc.name webgl2_test_bufferSubData_7 3016 * @tc.desc Test bufferSubData. 3017 */ 3018 it('webgl2_test_bufferSubData_7', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 3019 console.info("webgl2test [webgl2_test_bufferSubData_7] bufferSubData"); 3020 bufferSubData(() => { 3021 gl.bufferSubData(gl.PIXEL_UNPACK_BUFFER, 0, new Float32Array([ 3022 -1.0, -1.0, 0.0, 3023 1.0, -1.0, 0.0, 3024 -1.0, 1.0, 0.0 3025 ])); 3026 }, (result) => { 3027 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 3028 }); 3029 done(); 3030 }); 3031 }) 3032} 3033