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