1/* 2 * Copyright (c) 2023-2024 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 16#include "napi/native_api.h" 17#include "native_common.h" 18 19#include <ace/xcomponent/native_interface_xcomponent.h> 20#include <EGL/egl.h> 21#include <EGL/eglext.h> 22#include <EGL/eglplatform.h> 23#include <GLES3/gl32.h> 24 25#include <cmath> 26#include <node_api.h> 27 28#define NUMERIC_VALUE 29#ifdef NUMERIC_VALUE 30 31#define ARRAY_INDEX_ZERO 0 32#define ARRAY_INDEX_ONE 1 33#define ARRAY_INDEX_TWO 2 34#define ARRAY_INDEX_THREE 3 35#define ARRAY_INDEX_FORE 4 36#define INT_INIT_VAL 0 37#define CREAT_ERROR 0 38#define CREAT_NUM_ONE 1 39#define PIPELINES_NUM_ONE 1 40#define INFO_LEN_ONE 1 41#define TEXTURES_NUM_ONE 1 42#define IMAGE2D_LEVEL 0 43#define IMAGE_WIDTH 256 44#define IMAGE_HEIGHT 256 45#define IMAGE_DEPTH 256 46#define IMAGE_BORDER 0 47#define GL_BUF_SIZE 256 48#define GEN_BUF_NUM 1 49#define COUNT_NUM 1 50#define ATTRIB_INDEX 0 51#define VERTEX_NUM 3 52#define RGB_SIZE 8 53#define INIT_WIDTH 480 54#define INIT_HEIGHT 800 55#define INIT_EGL_VERSION 3 56#define VARYING_NUM 2 57#define ATTRIB_SIZE 3 58#define FRAME_BUFFER_OBJECT 2 59#define CLEAR_00 0.0f 60#define CLEAR_01 0.1f 61#define CLEAR_10 1.0f 62#define CLEAR_50 5.0f 63#define SUB_DATA_SIZE 32 64#define COMPUTE_VAL 10 65#define POINT_LIGHT_COUNT 4 66#define MATRIX_2 2 67#define MATRIX_3 3 68#define MATRIX_4 4 69#define MATRIX_6 6 70#define MATRIX_8 8 71#define MATRIX_9 9 72#define MATRIX_12 12 73#define MATRIX_15 15 74#define MATRIX_16 16 75#define IMAGE2D_LEVEL_ONE 1 76#define TIME_OUT 1000000000 77#define SAMPLES 4 78#define OFF_SET 32 79#define TEX_BUF_SIZE 1024 80 81#undef LOG_TAG 82#undef LOG_DOMAIN 83#define LOG_TAG "gl32" 84#define LOG_DOMAIN 0xFEFE 85#define GL_MAX_TEST_NUM 0xFFFF 86#define GL_CLIENT_VERSION 0x02 87#define GL_MAJOR_VERSION_2 0x02 88#define GL_MAJOR_VERSION_3 0x03 89#define GL_MINOR_VERSION_0 0x00 90#endif 91 92#define STATE_VALUE 93#ifdef STATE_VALUE 94 95#define SUCCESS 0 96#define FAILED -1 97#endif 98 99typedef struct _EGLWindow { 100 EGLDisplay eglDisPlay; 101 EGLSurface eglLSurface; 102 EGLContext eglContext; 103} EGLWindow; 104 105static void initGLES(EGLWindow *eglWindow) 106{ 107 if (eglWindow == nullptr) { 108 return; 109 } 110 eglWindow->eglDisPlay = eglGetDisplay(EGL_DEFAULT_DISPLAY); 111 if (eglWindow->eglDisPlay == EGL_NO_DISPLAY) { 112 return; 113 } 114 EGLint majorVersion = GL_MAJOR_VERSION_2; 115 EGLint minorVersion = GL_MINOR_VERSION_0; 116 EGLBoolean ret = eglInitialize(eglWindow->eglDisPlay, &majorVersion, &minorVersion); 117 if (ret == EGL_FALSE) { 118 return; 119 } 120 EGLint clientVersion = majorVersion == GL_MAJOR_VERSION_3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT; 121 const EGLint configAttribs[] = { 122 EGL_RED_SIZE, RGB_SIZE, EGL_GREEN_SIZE, RGB_SIZE, EGL_BLUE_SIZE, RGB_SIZE, 123 EGL_ALPHA_SIZE, RGB_SIZE, EGL_RENDERABLE_TYPE, clientVersion, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, 124 EGL_NONE}; 125 EGLConfig config = nullptr; 126 EGLint numConfigs = 0x00; 127 ret = eglChooseConfig(eglWindow->eglDisPlay, configAttribs, &config, GL_ONE, &numConfigs); 128 if (ret == EGL_FALSE) { 129 return; 130 } 131 const EGLint surfaceAttribs[] = {EGL_WIDTH, INIT_WIDTH, EGL_HEIGHT, 132 INIT_HEIGHT, EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, 133 EGL_TEXTURE_TARGET, EGL_TEXTURE_2D, EGL_NONE}; 134 eglWindow->eglLSurface = eglCreatePbufferSurface(eglWindow->eglDisPlay, config, surfaceAttribs); 135 if (eglWindow->eglLSurface == EGL_NO_SURFACE) { 136 return; 137 } 138 const EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, GL_CLIENT_VERSION, EGL_NONE}; 139 eglWindow->eglContext = eglCreateContext(eglWindow->eglDisPlay, config, EGL_NO_CONTEXT, contextAttribs); 140 if (eglWindow->eglContext == EGL_NO_CONTEXT) { 141 return; 142 } 143 eglMakeCurrent(eglWindow->eglDisPlay, eglWindow->eglLSurface, eglWindow->eglLSurface, 144 eglWindow->eglContext); 145 return; 146} 147 148static void destroyGLES(EGLWindow *eglWindow) 149{ 150 if (eglWindow == nullptr) { 151 return; 152 } 153 if (eglWindow->eglDisPlay != EGL_NO_DISPLAY && eglWindow->eglLSurface != EGL_NO_SURFACE) { 154 eglDestroySurface(eglWindow->eglDisPlay, eglWindow->eglLSurface); 155 } 156 if (eglWindow->eglDisPlay != EGL_NO_DISPLAY && eglWindow->eglContext != EGL_NO_CONTEXT) { 157 eglDestroyContext(eglWindow->eglDisPlay, eglWindow->eglContext); 158 } 159 if (eglWindow->eglDisPlay != EGL_NO_DISPLAY) { 160 eglTerminate(eglWindow->eglDisPlay); 161 } 162 eglSwapBuffers(eglWindow->eglDisPlay, eglWindow->eglLSurface); 163 eglWindow->eglDisPlay = EGL_NO_DISPLAY; 164 eglWindow->eglLSurface = EGL_NO_SURFACE; 165 eglWindow->eglContext = EGL_NO_CONTEXT; 166 return; 167} 168 169static const char *vertexSource = "attribute vec4 position;\n" 170 "uniform mat4 mvpMatrix;\n" 171 "void main() {\n" 172 " gl_Position = mvpMatrix * position;\n" 173 "}\n"; 174 175static const char *fragmentSource = "precision mediump float;\n" 176 "uniform float color;\n" 177 "void main() {\n" 178 " gl_FragColor = vec4(color, 0.0, 0.0, 1.0);\n;\n" 179 "}\n"; 180 181static const char *vertexShaderSource = " #version 300 es \n\ 182 layout(location = 0) in vec4 vPosition; \n\ 183 layout (std140) uniform MatrixBlock { \n\ 184 mat4 viewMatrix; \n\ 185 mat4 projMatrix; \n\ 186 } matrices; \n\ 187 \n\ 188 void main() \n\ 189 { \n\ 190 gl_Position = vPosition; \n\ 191 } "; 192static const char *fragmentShaderSource = " #version 300 es \n\ 193 precision mediump float; \n\ 194 out vec4 fragColor; \n\ 195 void main() \n\ 196 { \n\ 197 fragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 ); \n\ 198 }"; 199 200static const char *fragmentShaderSourceCompute = "#version 310 es\n\ 201 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n\ 202 layout(std430, binding = 0) buffer OutputBuffer {\n\ 203 float data[];\n\ 204 } outputBuffer;\n\ 205 void main() {\n\ 206 uint index = gl_GlobalInvocationID.x;\n\ 207 outputBuffer.data[index] = float(index);\n\ 208 }"; 209static const char *fragmentShaderSourceComputeIndirect = "#version 310 es\n\ 210 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n\ 211 layout(std430, binding = 0) buffer OutputBuffer {\n\ 212 float data[];\n\ 213 } outputBuffer;\n\ 214 void main() {\n\ 215 uint index = gl_GlobalInvocationID.x;\n\ 216 outputBuffer.data[index] = float(index);\n\ 217 }"; 218static EGLDisplay display = nullptr; 219static EGLContext context = nullptr; 220static EGLSurface surface = nullptr; 221 222GLuint esLoadShader(GLenum type, const char *shaderSrc); 223static napi_value getError(const napi_env env, const GLenum glError); 224void initGLES(); 225void destroyGLES(); 226 227void initGLES() 228{ 229 display = eglGetDisplay(EGL_DEFAULT_DISPLAY); 230 eglInitialize(display, nullptr, nullptr); 231 EGLint numConfigs = INT_INIT_VAL; 232 const EGLint configAttribs[] = {EGL_RED_SIZE, RGB_SIZE, EGL_GREEN_SIZE, RGB_SIZE, 233 EGL_BLUE_SIZE, RGB_SIZE, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, 234 EGL_NONE}; 235 EGLConfig config = nullptr; 236 eglChooseConfig(display, configAttribs, &config, CREAT_NUM_ONE, &numConfigs); 237 const EGLint surfaceAttribs[] = {EGL_WIDTH, INIT_WIDTH, EGL_HEIGHT, INIT_HEIGHT, EGL_NONE}; 238 surface = eglCreatePbufferSurface(display, config, surfaceAttribs); 239 const EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, INIT_EGL_VERSION, EGL_NONE}; 240 context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs); 241 eglMakeCurrent(display, surface, surface, context); 242} 243void destroyGLES() 244{ 245 eglDestroySurface(display, surface); 246 eglDestroyContext(display, context); 247 eglTerminate(display); 248 eglSwapBuffers(display, surface); 249} 250 251static napi_value getError(const napi_env env, const GLenum glError) 252{ 253 napi_value result = nullptr; 254 if (GL_NO_ERROR == glError) { 255 napi_create_int32(env, SUCCESS, &result); 256 } else { 257 napi_create_int32(env, FAILED, &result); 258 } 259 return result; 260} 261 262GLuint esLoadShader(GLenum type, const char *shaderSrc) 263{ 264 GLuint shader = INT_INIT_VAL; 265 shader = glCreateShader(type); 266 if (CREAT_ERROR == shader) { 267 return CREAT_ERROR; 268 } 269 glShaderSource(shader, CREAT_NUM_ONE, &shaderSrc, nullptr); 270 glCompileShader(shader); 271 return shader; 272} 273 274static GLuint shaderVertex = INT_INIT_VAL; 275static GLuint shaderFragment = INT_INIT_VAL; 276static GLuint initProgram(void) 277{ 278 shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 279 shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 280 GLuint programObject = glCreateProgram(); 281 glAttachShader(programObject, shaderVertex); 282 glAttachShader(programObject, shaderFragment); 283 glLinkProgram(programObject); 284 return programObject; 285} 286 287static GLuint initProgram(const char *vertexSource, const char *fragmentSource) 288{ 289 shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexSource); 290 shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentSource); 291 GLuint programObject = glCreateProgram(); 292 glAttachShader(programObject, shaderVertex); 293 glAttachShader(programObject, shaderFragment); 294 glLinkProgram(programObject); 295 return programObject; 296} 297 298static void deleteProgram(void) 299{ 300 glDeleteShader(shaderVertex); 301 glDeleteShader(shaderFragment); 302} 303 304static napi_value GLActiveShaderProgram(napi_env env, napi_callback_info info) 305{ 306 GLenum glError = GL_NO_ERROR; 307 initGLES(); 308 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 309 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 310 GLuint programObjectRed = glCreateProgram(); 311 glAttachShader(programObjectRed, shaderVertex); 312 glAttachShader(programObjectRed, shaderFragment); 313 glLinkProgram(programObjectRed); 314 GLuint programObjectGreen = glCreateProgram(); 315 glAttachShader(programObjectGreen, shaderVertex); 316 glAttachShader(programObjectGreen, shaderFragment); 317 glLinkProgram(programObjectGreen); 318 glUseProgram(programObjectRed); 319 GLuint pipeline = INT_INIT_VAL; 320 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 321 glActiveShaderProgram(pipeline, programObjectGreen); 322 glError = glGetError(); 323 glDeleteShader(shaderVertex); 324 glDeleteShader(shaderFragment); 325 glDeleteProgram(programObjectRed); 326 glDeleteProgram(programObjectGreen); 327 glDeleteProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 328 destroyGLES(); 329 napi_value result = nullptr; 330 if (GL_NO_ERROR == glError) { 331 napi_create_int32(env, SUCCESS, &result); 332 } else { 333 napi_create_int32(env, FAILED, &result); 334 } 335 return result; 336} 337 338static napi_value GLActiveTexture(napi_env env, napi_callback_info info) 339{ 340 GLenum glError = GL_NO_ERROR; 341 initGLES(); 342 GLuint textureId = INT_INIT_VAL; 343 glGenTextures(TEXTURES_NUM_ONE, &textureId); 344 glBindTexture(GL_TEXTURE_2D, textureId); 345 glActiveTexture(GL_TEXTURE0); 346 glError = glGetError(); 347 glDeleteTextures(TEXTURES_NUM_ONE, &textureId); 348 destroyGLES(); 349 return getError(env, glError); 350} 351 352static napi_value GLAttachShader(napi_env env, napi_callback_info info) 353{ 354 GLenum glError = GL_NO_ERROR; 355 initGLES(); 356 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 357 GLuint programObjectRed = glCreateProgram(); 358 glAttachShader(programObjectRed, shaderVertex); 359 glError = glGetError(); 360 glLinkProgram(programObjectRed); 361 glDeleteShader(shaderVertex); 362 glDeleteProgram(programObjectRed); 363 destroyGLES(); 364 return getError(env, glError); 365} 366 367static napi_value GLBeginQuery(napi_env env, napi_callback_info info) 368{ 369 GLenum glError = GL_NO_ERROR; 370 initGLES(); 371 GLuint queryID = INT_INIT_VAL; 372 glGenQueries(1, &queryID); 373 glBeginQuery(GL_ANY_SAMPLES_PASSED, queryID); 374 glError = glGetError(); 375 glEndQuery(GL_ANY_SAMPLES_PASSED); 376 destroyGLES(); 377 return getError(env, glError); 378} 379 380static napi_value GLBeginTransformFeedback(napi_env env, napi_callback_info info) 381{ 382 GLenum glError = GL_NO_ERROR; 383 initGLES(); 384 GLuint tfBuffer; 385 glGenBuffers(CREAT_NUM_ONE, &tfBuffer); 386 GLuint vao; 387 glGenVertexArrays(CREAT_NUM_ONE, &vao); 388 glBindVertexArray(vao); 389 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 390 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 391 GLuint programObject = glCreateProgram(); 392 glAttachShader(programObject, shaderVertex); 393 glAttachShader(programObject, shaderFragment); 394 glLinkProgram(programObject); 395 glUseProgram(programObject); 396 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, INT_INIT_VAL, tfBuffer); 397 glTransformFeedbackVaryings(programObject, VARYING_NUM, (const char *[]){"gl_Position", "vColor"}, 398 GL_SEPARATE_ATTRIBS); 399 glEnable(GL_RASTERIZER_DISCARD); 400 glBeginTransformFeedback(GL_POINTS); 401 glError = glGetError(); 402 glEndTransformFeedback(); 403 glDeleteShader(shaderVertex); 404 glDeleteShader(shaderFragment); 405 glDeleteProgram(programObject); 406 destroyGLES(); 407 return getError(env, glError); 408} 409 410static napi_value GLBindAttribLocation(napi_env env, napi_callback_info info) 411{ 412 GLenum glError = GL_NO_ERROR; 413 initGLES(); 414 GLuint programID = INT_INIT_VAL; 415 GLuint vertexShader = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 416 GLuint fragmentShader = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 417 programID = glCreateProgram(); 418 glAttachShader(programID, vertexShader); 419 glAttachShader(programID, fragmentShader); 420 glBindAttribLocation(programID, ATTRIB_INDEX, "position"); 421 glError = glGetError(); 422 glDeleteShader(vertexShader); 423 glDeleteShader(fragmentShader); 424 glDeleteProgram(programID); 425 destroyGLES(); 426 return getError(env, glError); 427} 428 429static napi_value GLBindBuffer(napi_env env, napi_callback_info info) 430{ 431 GLenum glError = GL_NO_ERROR; 432 initGLES(); 433 GLuint bufferID = INT_INIT_VAL; 434 glGenBuffers(GEN_BUF_NUM, &bufferID); 435 glBindBuffer(GL_ARRAY_BUFFER, bufferID); 436 glError = glGetError(); 437 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 438 destroyGLES(); 439 return getError(env, glError); 440} 441 442static napi_value GLBindBufferBase(napi_env env, napi_callback_info info) 443{ 444 GLenum glError = GL_NO_ERROR; 445 initGLES(); 446 GLuint bufferID = INT_INIT_VAL; 447 glGenBuffers(GEN_BUF_NUM, &bufferID); 448 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, INT_INIT_VAL, bufferID); 449 glError = glGetError(); 450 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 451 destroyGLES(); 452 return getError(env, glError); 453} 454 455static napi_value GLBindBufferRange(napi_env env, napi_callback_info info) 456{ 457 GLenum glError = GL_NO_ERROR; 458 initGLES(); 459 GLuint bufferID = INT_INIT_VAL; 460 glGenBuffers(GEN_BUF_NUM, &bufferID); 461 GLint data[] = {2, 4, 6, 8}; 462 glBindBufferRange(GL_SHADER_STORAGE_BUFFER, INT_INIT_VAL, bufferID, INT_INIT_VAL, sizeof(data)); 463 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), data, GL_STATIC_DRAW); 464 glError = glGetError(); 465 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 466 destroyGLES(); 467 return getError(env, glError); 468} 469 470static napi_value GLBindFramebuffer(napi_env env, napi_callback_info info) 471{ 472 initGLES(); 473 GLuint fbo = INT_INIT_VAL; 474 glGenFramebuffers(CREAT_NUM_ONE, &fbo); 475 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 476 napi_value result = nullptr; 477 if (CREAT_ERROR != glCheckFramebufferStatus(GL_FRAMEBUFFER)) { 478 napi_create_int32(env, SUCCESS, &result); 479 } else { 480 napi_create_int32(env, FAILED, &result); 481 } 482 glDeleteFramebuffers(CREAT_NUM_ONE, &fbo); 483 destroyGLES(); 484 return result; 485} 486 487static napi_value GLBindImageTexture(napi_env env, napi_callback_info info) 488{ 489 GLenum glError = GL_NO_ERROR; 490 initGLES(); 491 GLuint textureId = INT_INIT_VAL; 492 glGenTextures(TEXTURES_NUM_ONE, &textureId); 493 glBindTexture(GL_TEXTURE_2D, textureId); 494 glTexStorage2D(GL_TEXTURE_2D, RGB_SIZE, GL_RGBA8, INIT_WIDTH, INIT_HEIGHT); 495 GLuint imageBindingIndex = INT_INIT_VAL; 496 glBindImageTexture(imageBindingIndex, textureId, INT_INIT_VAL, GL_FALSE, INT_INIT_VAL, GL_READ_WRITE, GL_RGBA8); 497 glError = glGetError(); 498 glDeleteTextures(TEXTURES_NUM_ONE, &textureId); 499 destroyGLES(); 500 return getError(env, glError); 501} 502 503static napi_value GLBindProgramPipeline(napi_env env, napi_callback_info info) 504{ 505 GLenum glError = GL_NO_ERROR; 506 initGLES(); 507 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 508 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 509 GLuint programObject = glCreateProgram(); 510 glAttachShader(programObject, shaderVertex); 511 glAttachShader(programObject, shaderFragment); 512 glLinkProgram(programObject); 513 glUseProgram(programObject); 514 GLuint pipeline = INT_INIT_VAL; 515 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 516 glBindProgramPipeline(pipeline); 517 glError = glGetError(); 518 glDeleteShader(shaderVertex); 519 glDeleteShader(shaderFragment); 520 glDeleteProgram(programObject); 521 glDeleteProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 522 destroyGLES(); 523 return getError(env, glError); 524} 525 526static napi_value GLBindRenderbuffer(napi_env env, napi_callback_info info) 527{ 528 GLenum glError = GL_NO_ERROR; 529 initGLES(); 530 GLuint rbo; 531 glGenRenderbuffers(CREAT_NUM_ONE, &rbo); 532 glBindRenderbuffer(GL_RENDERBUFFER, rbo); 533 glError = glGetError(); 534 glDeleteRenderbuffers(CREAT_NUM_ONE, &rbo); 535 destroyGLES(); 536 return getError(env, glError); 537} 538 539static napi_value GLBindSampler(napi_env env, napi_callback_info info) 540{ 541 GLenum glError = GL_NO_ERROR; 542 initGLES(); 543 GLuint textureId = INT_INIT_VAL; 544 glGenTextures(TEXTURES_NUM_ONE, &textureId); 545 glBindTexture(GL_TEXTURE_2D, textureId); 546 GLuint sampler = INT_INIT_VAL; 547 glGenSamplers(CREAT_NUM_ONE, &sampler); 548 glBindSampler(textureId, sampler); 549 glError = glGetError(); 550 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 551 glDeleteTextures(TEXTURES_NUM_ONE, &textureId); 552 destroyGLES(); 553 return getError(env, glError); 554} 555 556static napi_value GLBindTexture(napi_env env, napi_callback_info info) 557{ 558 GLenum glError = GL_NO_ERROR; 559 initGLES(); 560 GLuint textureId = INT_INIT_VAL; 561 glGenTextures(TEXTURES_NUM_ONE, &textureId); 562 glBindTexture(GL_TEXTURE_2D, textureId); 563 glError = glGetError(); 564 glDeleteTextures(TEXTURES_NUM_ONE, &textureId); 565 destroyGLES(); 566 return getError(env, glError); 567} 568 569static napi_value GLBindTransformFeedback(napi_env env, napi_callback_info info) 570{ 571 GLenum glError = GL_NO_ERROR; 572 initGLES(); 573 GLuint transformFeedback; 574 glGenTransformFeedbacks(CREAT_NUM_ONE, &transformFeedback); 575 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback); 576 glError = glGetError(); 577 glDeleteTransformFeedbacks(CREAT_NUM_ONE, &transformFeedback); 578 destroyGLES(); 579 return getError(env, glError); 580} 581 582static napi_value GLBindVertexArray(napi_env env, napi_callback_info info) 583{ 584 GLenum glError = GL_NO_ERROR; 585 initGLES(); 586 GLuint vao; 587 glGenVertexArrays(CREAT_NUM_ONE, &vao); 588 glBindVertexArray(vao); 589 glError = glGetError(); 590 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 591 destroyGLES(); 592 return getError(env, glError); 593} 594 595static napi_value GLBindVertexBuffer(napi_env env, napi_callback_info info) 596{ 597 GLenum glError = GL_NO_ERROR; 598 initGLES(); 599 GLfloat vertices[] = {CLEAR_00, 0.5f, CLEAR_00, -0.5f, -0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00}; 600 GLuint VAO; 601 GLuint VBO; 602 glGenVertexArrays(CREAT_NUM_ONE, &VAO); 603 glBindVertexArray(VAO); 604 glGenBuffers(CREAT_NUM_ONE, &VBO); 605 glBindBuffer(GL_ARRAY_BUFFER, VBO); 606 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 607 glVertexAttribPointer(INT_INIT_VAL, ATTRIB_SIZE, GL_FLOAT, GL_FALSE, INT_INIT_VAL, INT_INIT_VAL); 608 glEnableVertexAttribArray(INT_INIT_VAL); 609 glBindVertexBuffer(INT_INIT_VAL, VBO, INT_INIT_VAL, sizeof(vertices)); 610 glError = glGetError(); 611 glDeleteBuffers(CREAT_NUM_ONE, &VBO); 612 destroyGLES(); 613 return getError(env, glError); 614} 615 616static napi_value GLBlendBarrier(napi_env env, napi_callback_info info) 617{ 618 GLenum glError = GL_NO_ERROR; 619 initGLES(); 620 glEnable(GL_BLEND); 621 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 622 glBlendBarrier(); 623 glError = glGetError(); 624 glDisable(GL_BLEND); 625 destroyGLES(); 626 return getError(env, glError); 627} 628 629static napi_value GLBlendColor(napi_env env, napi_callback_info info) 630{ 631 GLenum glError = GL_NO_ERROR; 632 initGLES(); 633 glClear(GL_COLOR_BUFFER_BIT); 634 glEnable(GL_BLEND); 635 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 636 glBlendColor(CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10); 637 glError = glGetError(); 638 glDisable(GL_BLEND); 639 destroyGLES(); 640 return getError(env, glError); 641} 642 643static napi_value GLBlendEquation(napi_env env, napi_callback_info info) 644{ 645 GLenum glError = GL_NO_ERROR; 646 initGLES(); 647 glClear(GL_COLOR_BUFFER_BIT); 648 glEnable(GL_BLEND); 649 glBlendEquation(GL_FUNC_ADD); 650 glError = glGetError(); 651 glDisable(GL_BLEND); 652 destroyGLES(); 653 return getError(env, glError); 654} 655 656static napi_value GLBlendEquationi(napi_env env, napi_callback_info info) 657{ 658 GLenum glError = GL_NO_ERROR; 659 initGLES(); 660 glClear(GL_COLOR_BUFFER_BIT); 661 glEnable(GL_BLEND); 662 glBlendEquationi(CREAT_NUM_ONE, GL_FUNC_ADD); 663 glError = glGetError(); 664 glDisable(GL_BLEND); 665 destroyGLES(); 666 return getError(env, glError); 667} 668 669static napi_value GLBlendEquationSeparate(napi_env env, napi_callback_info info) 670{ 671 GLenum glError = GL_NO_ERROR; 672 initGLES(); 673 glClear(GL_COLOR_BUFFER_BIT); 674 glEnable(GL_BLEND); 675 glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_MAX); 676 glError = glGetError(); 677 glDisable(GL_BLEND); 678 destroyGLES(); 679 return getError(env, glError); 680} 681 682static napi_value GLBlendEquationSeparatei(napi_env env, napi_callback_info info) 683{ 684 GLenum glError = GL_NO_ERROR; 685 initGLES(); 686 glClear(GL_COLOR_BUFFER_BIT); 687 glEnable(GL_BLEND); 688 glBlendEquationSeparatei(INT_INIT_VAL, GL_FUNC_REVERSE_SUBTRACT, GL_MAX); 689 glError = glGetError(); 690 glDisable(GL_BLEND); 691 destroyGLES(); 692 return getError(env, glError); 693} 694 695static napi_value GLBlendFunc(napi_env env, napi_callback_info info) 696{ 697 GLenum glError = GL_NO_ERROR; 698 initGLES(); 699 glEnable(GL_BLEND); 700 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 701 glError = glGetError(); 702 glDisable(GL_BLEND); 703 destroyGLES(); 704 return getError(env, glError); 705} 706 707static napi_value GLBlendFunci(napi_env env, napi_callback_info info) 708{ 709 GLenum glError = GL_NO_ERROR; 710 initGLES(); 711 glEnable(GL_BLEND); 712 glBlendFunci(INT_INIT_VAL, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 713 glError = glGetError(); 714 glDisable(GL_BLEND); 715 destroyGLES(); 716 return getError(env, glError); 717} 718 719static napi_value GLBlendFuncSeparate(napi_env env, napi_callback_info info) 720{ 721 GLenum glError = GL_NO_ERROR; 722 initGLES(); 723 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO); 724 glError = glGetError(); 725 destroyGLES(); 726 return getError(env, glError); 727} 728 729static napi_value GLBlendFuncSeparatei(napi_env env, napi_callback_info info) 730{ 731 GLenum glError = GL_NO_ERROR; 732 initGLES(); 733 glBlendFuncSeparatei(INT_INIT_VAL, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO); 734 glError = glGetError(); 735 destroyGLES(); 736 return getError(env, glError); 737} 738 739static napi_value GLBlitFramebuffer(napi_env env, napi_callback_info info) 740{ 741 GLenum glError = GL_NO_ERROR; 742 initGLES(); 743 GLuint framebuffer; 744 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 745 glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer); 746 GLuint texture; 747 glGenTextures(CREAT_NUM_ONE, &texture); 748 glBindTexture(GL_TEXTURE_2D, texture); 749 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGBA, INIT_WIDTH, INIT_HEIGHT, INT_INIT_VAL, GL_RGBA, GL_UNSIGNED_BYTE, 750 nullptr); 751 glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, INT_INIT_VAL); 752 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, INT_INIT_VAL); 753 glBlitFramebuffer(INT_INIT_VAL, INT_INIT_VAL, INIT_WIDTH, INIT_HEIGHT, INT_INIT_VAL, INT_INIT_VAL, INIT_WIDTH, 754 INIT_HEIGHT, GL_COLOR_BUFFER_BIT, GL_LINEAR); 755 glError = glGetError(); 756 glDeleteTextures(CREAT_NUM_ONE, &texture); 757 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 758 destroyGLES(); 759 return getError(env, glError); 760} 761 762static napi_value GLBufferData(napi_env env, napi_callback_info info) 763{ 764 GLenum glError = GL_NO_ERROR; 765 initGLES(); 766 GLuint bufferID; 767 GLfloat vertices[] = {CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00}; 768 glGenBuffers(CREAT_NUM_ONE, &bufferID); 769 glBindBuffer(GL_ARRAY_BUFFER, bufferID); 770 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 771 glError = glGetError(); 772 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 773 destroyGLES(); 774 return getError(env, glError); 775} 776 777static napi_value GLBufferSubData(napi_env env, napi_callback_info info) 778{ 779 GLenum glError = GL_NO_ERROR; 780 initGLES(); 781 GLuint bufferID; 782 GLfloat vertices[] = {CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00}; 783 glGenBuffers(CREAT_NUM_ONE, &bufferID); 784 glBindBuffer(GL_ARRAY_BUFFER, bufferID); 785 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 786 GLfloat newData[] = {CLEAR_00, CLEAR_00}; 787 glBufferSubData(GL_ARRAY_BUFFER, sizeof(GLfloat) * ATTRIB_SIZE, sizeof(newData), newData); 788 glError = glGetError(); 789 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 790 destroyGLES(); 791 return getError(env, glError); 792} 793 794static napi_value GLCheckFramebufferStatus(napi_env env, napi_callback_info info) 795{ 796 initGLES(); 797 GLuint fbo = INT_INIT_VAL; 798 glGenFramebuffers(CREAT_NUM_ONE, &fbo); 799 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 800 napi_value result = nullptr; 801 if (CREAT_ERROR != glCheckFramebufferStatus(GL_FRAMEBUFFER)) { 802 napi_create_int32(env, SUCCESS, &result); 803 } else { 804 napi_create_int32(env, FAILED, &result); 805 } 806 glDeleteFramebuffers(CREAT_NUM_ONE, &fbo); 807 destroyGLES(); 808 return result; 809} 810 811static napi_value GLClear(napi_env env, napi_callback_info info) 812{ 813 GLenum glError = GL_NO_ERROR; 814 initGLES(); 815 glClear(GL_COLOR_BUFFER_BIT); 816 glError = glGetError(); 817 destroyGLES(); 818 return getError(env, glError); 819} 820 821static napi_value GLClearBufferfi(napi_env env, napi_callback_info info) 822{ 823 GLenum glError = GL_NO_ERROR; 824 initGLES(); 825 GLuint bufferID = INT_INIT_VAL; 826 glGenBuffers(GEN_BUF_NUM, &bufferID); 827 glBindBuffer(GL_ARRAY_BUFFER, bufferID); 828 glClearBufferfi(GL_DEPTH_STENCIL, INT_INIT_VAL, CLEAR_00, INT_INIT_VAL); 829 glError = glGetError(); 830 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 831 destroyGLES(); 832 return getError(env, glError); 833} 834 835static napi_value GLClearBufferfv(napi_env env, napi_callback_info info) 836{ 837 GLenum glError = GL_NO_ERROR; 838 initGLES(); 839 GLfloat clearColor[] = {CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00}; 840 GLuint bufferID = INT_INIT_VAL; 841 glGenBuffers(GEN_BUF_NUM, &bufferID); 842 glBindBuffer(GL_ARRAY_BUFFER, bufferID); 843 glClearBufferfv(GL_COLOR, INT_INIT_VAL, clearColor); 844 glError = glGetError(); 845 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 846 destroyGLES(); 847 return getError(env, glError); 848} 849 850static napi_value GLClearBufferiv(napi_env env, napi_callback_info info) 851{ 852 GLenum glError = GL_NO_ERROR; 853 initGLES(); 854 GLuint bufferID = INT_INIT_VAL; 855 glGenBuffers(GEN_BUF_NUM, &bufferID); 856 glBindBuffer(GL_ARRAY_BUFFER, bufferID); 857 GLint clearStencil = INT_INIT_VAL; 858 glClearBufferiv(GL_STENCIL, INT_INIT_VAL, &clearStencil); 859 glError = glGetError(); 860 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 861 destroyGLES(); 862 return getError(env, glError); 863} 864 865static napi_value GLClearBufferuiv(napi_env env, napi_callback_info info) 866{ 867 GLenum glError = GL_NO_ERROR; 868 initGLES(); 869 GLuint bufferID = INT_INIT_VAL; 870 glGenBuffers(GEN_BUF_NUM, &bufferID); 871 glBindBuffer(GL_ARRAY_BUFFER, bufferID); 872 GLuint clearColor[] = {INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL}; 873 glClearBufferuiv(GL_COLOR, INT_INIT_VAL, clearColor); 874 glError = glGetError(); 875 glDeleteBuffers(GEN_BUF_NUM, &bufferID); 876 destroyGLES(); 877 return getError(env, glError); 878} 879 880static napi_value GLClearColor(napi_env env, napi_callback_info info) 881{ 882 GLenum glError = GL_NO_ERROR; 883 initGLES(); 884 glClearColor(CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00); 885 glError = glGetError(); 886 destroyGLES(); 887 return getError(env, glError); 888} 889 890static napi_value GLClearDepthf(napi_env env, napi_callback_info info) 891{ 892 GLenum glError = GL_NO_ERROR; 893 initGLES(); 894 glClearDepthf(CLEAR_00); 895 glError = glGetError(); 896 destroyGLES(); 897 return getError(env, glError); 898} 899 900static napi_value GLClearStencil(napi_env env, napi_callback_info info) 901{ 902 GLenum glError = GL_NO_ERROR; 903 initGLES(); 904 glClearStencil(INT_INIT_VAL); 905 glError = glGetError(); 906 destroyGLES(); 907 return getError(env, glError); 908} 909 910static napi_value GLClientWaitSync(napi_env env, napi_callback_info info) 911{ 912 napi_value result = nullptr; 913 initGLES(); 914 GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, INT_INIT_VAL); 915 if (GL_WAIT_FAILED != glClientWaitSync(sync, INT_INIT_VAL, INT_INIT_VAL)) { 916 napi_create_int32(env, SUCCESS, &result); 917 } else { 918 napi_create_int32(env, FAILED, &result); 919 } 920 glDeleteSync(sync); 921 destroyGLES(); 922 return result; 923} 924 925static napi_value GLColorMask(napi_env env, napi_callback_info info) 926{ 927 GLenum glError = GL_NO_ERROR; 928 initGLES(); 929 glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE); 930 glError = glGetError(); 931 destroyGLES(); 932 return getError(env, glError); 933} 934 935static napi_value GLColorMaski(napi_env env, napi_callback_info info) 936{ 937 GLenum glError = GL_NO_ERROR; 938 initGLES(); 939 glColorMaski(INT_INIT_VAL, GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE); 940 glError = glGetError(); 941 destroyGLES(); 942 return getError(env, glError); 943} 944 945static napi_value GLCompileShader(napi_env env, napi_callback_info info) 946{ 947 GLenum glError = GL_NO_ERROR; 948 initGLES(); 949 glColorMaski(INT_INIT_VAL, GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE); 950 glError = glGetError(); 951 destroyGLES(); 952 return getError(env, glError); 953} 954 955static napi_value GLCompressedTexImage2D(napi_env env, napi_callback_info info) 956{ 957 GLenum glError = GL_NO_ERROR; 958 initGLES(); 959 GLuint tex = INT_INIT_VAL; 960 glGenTextures(CREAT_NUM_ONE, &tex); 961 glBindTexture(GL_TEXTURE_2D, tex); 962 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 963 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 964 GLubyte textureData[TEX_BUF_SIZE] = {INT_INIT_VAL}; 965 glCompressedTexImage2D( 966 GL_TEXTURE_2D, INT_INIT_VAL, GL_COMPRESSED_R11_EAC, SUB_DATA_SIZE, SUB_DATA_SIZE, INT_INIT_VAL, 967 ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * RGB_SIZE, textureData); 968 glError = glGetError(); 969 glDeleteTextures(CREAT_NUM_ONE, &tex); 970 destroyGLES(); 971 return getError(env, glError); 972} 973 974static napi_value GLCompressedTexImage3D(napi_env env, napi_callback_info info) 975{ 976 GLenum glError = GL_NO_ERROR; 977 initGLES(); 978 GLuint tex = INT_INIT_VAL; 979 glGenTextures(CREAT_NUM_ONE, &tex); 980 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 981 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 982 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 983 GLubyte textureData[TEX_BUF_SIZE] = {INT_INIT_VAL}; 984 glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, INT_INIT_VAL, GL_COMPRESSED_R11_EAC, SUB_DATA_SIZE, SUB_DATA_SIZE, 985 CREAT_NUM_ONE, INT_INIT_VAL, 986 ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * RGB_SIZE, 987 textureData); 988 glError = glGetError(); 989 glDeleteTextures(CREAT_NUM_ONE, &tex); 990 destroyGLES(); 991 return getError(env, glError); 992} 993 994static napi_value GLCompressedTexSubImage2D(napi_env env, napi_callback_info info) 995{ 996 initGLES(); 997 GLuint texture = INT_INIT_VAL; 998 GLubyte textureData[TEX_BUF_SIZE] = {INT_INIT_VAL}; 999 glGenTextures(CREAT_NUM_ONE, &texture); 1000 glBindTexture(GL_TEXTURE_2D, texture); 1001 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1002 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1003 glCompressedTexImage2D( 1004 GL_TEXTURE_2D, INT_INIT_VAL, GL_COMPRESSED_R11_EAC, SUB_DATA_SIZE, SUB_DATA_SIZE, INT_INIT_VAL, 1005 ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * RGB_SIZE, textureData); 1006 glCompressedTexSubImage2D( 1007 GL_TEXTURE_2D, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, RGB_SIZE, RGB_SIZE, GL_COMPRESSED_R11_EAC, 1008 ceil(RGB_SIZE / POINT_LIGHT_COUNT) * ceil(RGB_SIZE / POINT_LIGHT_COUNT) * RGB_SIZE, textureData); 1009 GLenum glError = glGetError(); 1010 glDeleteTextures(CREAT_NUM_ONE, &texture); 1011 destroyGLES(); 1012 return getError(env, glError); 1013} 1014 1015static napi_value GLCompressedTexSubImage3D(napi_env env, napi_callback_info info) 1016{ 1017 initGLES(); 1018 GLuint texture = INT_INIT_VAL; 1019 GLubyte textureData[TEX_BUF_SIZE] = {INT_INIT_VAL}; 1020 glGenTextures(CREAT_NUM_ONE, &texture); 1021 glBindTexture(GL_TEXTURE_2D_ARRAY, texture); 1022 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1023 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1024 glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, INT_INIT_VAL, GL_COMPRESSED_R11_EAC, SUB_DATA_SIZE, SUB_DATA_SIZE, 1025 CREAT_NUM_ONE, INT_INIT_VAL, 1026 ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * RGB_SIZE, 1027 textureData); 1028 glCompressedTexSubImage3D( 1029 GL_TEXTURE_2D_ARRAY, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, SUB_DATA_SIZE, SUB_DATA_SIZE, 1030 CREAT_NUM_ONE, GL_COMPRESSED_R11_EAC, 1031 ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * ceil(SUB_DATA_SIZE / POINT_LIGHT_COUNT) * RGB_SIZE, textureData); 1032 GLenum glError = glGetError(); 1033 glDeleteTextures(CREAT_NUM_ONE, &texture); 1034 destroyGLES(); 1035 return getError(env, glError); 1036} 1037 1038static napi_value GLCopyBufferSubData(napi_env env, napi_callback_info info) 1039{ 1040 initGLES(); 1041 GLuint buffer1 = INT_INIT_VAL, buffer2 = INT_INIT_VAL; 1042 glGenBuffers(CREAT_NUM_ONE, &buffer1); 1043 glGenBuffers(CREAT_NUM_ONE, &buffer2); 1044 glBindBuffer(GL_COPY_READ_BUFFER, buffer1); 1045 glBindBuffer(GL_COPY_WRITE_BUFFER, buffer2); 1046 GLfloat vertices[] = {CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00}; 1047 glBufferData(GL_COPY_READ_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1048 glBufferData(GL_COPY_WRITE_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1049 GLintptr readOffset = INT_INIT_VAL; 1050 GLintptr writeOffset = INT_INIT_VAL; 1051 GLsizeiptr size = SUB_DATA_SIZE; 1052 glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, readOffset, writeOffset, size); 1053 GLenum glError = glGetError(); 1054 glDeleteBuffers(CREAT_NUM_ONE, &buffer1); 1055 glDeleteBuffers(CREAT_NUM_ONE, &buffer2); 1056 destroyGLES(); 1057 return getError(env, glError); 1058} 1059 1060static napi_value GLCopyImageSubData(napi_env env, napi_callback_info info) 1061{ 1062 initGLES(); 1063 GLuint sourceTex, destTex; 1064 glGenTextures(CREAT_NUM_ONE, &sourceTex); 1065 glGenTextures(CREAT_NUM_ONE, &destTex); 1066 glBindTexture(GL_TEXTURE_2D, sourceTex); 1067 glTexStorage2D(GL_TEXTURE_2D, CREAT_NUM_ONE, GL_RGBA8, IMAGE_WIDTH, IMAGE_HEIGHT); 1068 glBindTexture(GL_TEXTURE_2D, destTex); 1069 glTexStorage2D(GL_TEXTURE_2D, CREAT_NUM_ONE, GL_RGBA8, IMAGE_WIDTH, IMAGE_HEIGHT); 1070 GLint srcX = INT_INIT_VAL; 1071 GLint srcY = INT_INIT_VAL; 1072 GLsizei srcWidth = IMAGE_WIDTH; 1073 GLsizei srcHeight = IMAGE_WIDTH; 1074 GLint destX = INT_INIT_VAL; 1075 GLint destY = INT_INIT_VAL; 1076 glCopyImageSubData(sourceTex, GL_TEXTURE_2D, INT_INIT_VAL, srcX, srcY, INT_INIT_VAL, destTex, GL_TEXTURE_2D, 1077 INT_INIT_VAL, destX, destY, INT_INIT_VAL, srcWidth, srcHeight, CREAT_NUM_ONE); 1078 GLenum glError = glGetError(); 1079 glDeleteTextures(CREAT_NUM_ONE, &destTex); 1080 glDeleteTextures(CREAT_NUM_ONE, &sourceTex); 1081 destroyGLES(); 1082 return getError(env, glError); 1083} 1084 1085static napi_value GLCopyTexImage2D(napi_env env, napi_callback_info info) 1086{ 1087 initGLES(); 1088 GLuint texture; 1089 GLuint fbo; 1090 glGenFramebuffers(CREAT_NUM_ONE, &fbo); 1091 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1092 glGenTextures(CREAT_NUM_ONE, &texture); 1093 glBindTexture(GL_TEXTURE_2D, texture); 1094 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, IMAGE_WIDTH, IMAGE_HEIGHT, INT_INIT_VAL, GL_RGB, GL_UNSIGNED_BYTE, 1095 nullptr); 1096 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, INT_INIT_VAL); 1097 glCopyTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, INT_INIT_VAL, INT_INIT_VAL, IMAGE_WIDTH, IMAGE_HEIGHT, 1098 INT_INIT_VAL); 1099 GLenum glError = glGetError(); 1100 glDeleteFramebuffers(CREAT_NUM_ONE, &fbo); 1101 glDeleteTextures(CREAT_NUM_ONE, &texture); 1102 destroyGLES(); 1103 return getError(env, glError); 1104} 1105 1106static napi_value GLCopyTexSubImage2D(napi_env env, napi_callback_info info) 1107{ 1108 initGLES(); 1109 GLuint texture; 1110 GLuint fbo; 1111 glGenFramebuffers(CREAT_NUM_ONE, &fbo); 1112 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1113 glGenTextures(CREAT_NUM_ONE, &texture); 1114 glBindTexture(GL_TEXTURE_2D, texture); 1115 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, IMAGE_WIDTH, IMAGE_HEIGHT, INT_INIT_VAL, GL_RGB, GL_UNSIGNED_BYTE, 1116 nullptr); 1117 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, INT_INIT_VAL); 1118 glCopyTexSubImage2D(GL_TEXTURE_2D, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, 1119 IMAGE_WIDTH, IMAGE_HEIGHT); 1120 GLenum glError = glGetError(); 1121 glDeleteFramebuffers(CREAT_NUM_ONE, &fbo); 1122 glDeleteTextures(CREAT_NUM_ONE, &texture); 1123 destroyGLES(); 1124 return getError(env, glError); 1125} 1126 1127static napi_value GLCopyTexSubImage3D(napi_env env, napi_callback_info info) 1128{ 1129 initGLES(); 1130 GLuint texture; 1131 glGenTextures(CREAT_NUM_ONE, &texture); 1132 glBindTexture(GL_TEXTURE_3D, texture); 1133 glTexImage3D(GL_TEXTURE_3D, INT_INIT_VAL, GL_R8, MATRIX_8, MATRIX_8, MATRIX_8, INT_INIT_VAL, 1134 GL_RED, GL_UNSIGNED_BYTE, nullptr); 1135 GLuint framebuffer; 1136 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 1137 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 1138 glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture, INT_INIT_VAL, MATRIX_8); 1139 glGenerateMipmap(GL_TEXTURE_3D); 1140 glTexImage3D(GL_TEXTURE_3D, INT_INIT_VAL, GL_R8UI, MATRIX_16, MATRIX_16, MATRIX_16, INT_INIT_VAL, 1141 GL_RED_INTEGER, GL_UNSIGNED_BYTE, nullptr); 1142 glCopyTexSubImage3D(GL_TEXTURE_3D, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, MATRIX_2, MATRIX_2, 1143 MATRIX_15, MATRIX_16, MATRIX_16); 1144 GLenum glError = glGetError(); 1145 destroyGLES(); 1146 return getError(env, glError); 1147} 1148 1149static napi_value GLCreateProgram(napi_env env, napi_callback_info info) 1150{ 1151 napi_value result = nullptr; 1152 initGLES(); 1153 GLuint programObject = glCreateProgram(); 1154 if (CREAT_ERROR != programObject) { 1155 napi_create_int32(env, SUCCESS, &result); 1156 } else { 1157 napi_create_int32(env, FAILED, &result); 1158 } 1159 glDeleteProgram(programObject); 1160 destroyGLES(); 1161 return result; 1162} 1163 1164static napi_value GLCreateShader(napi_env env, napi_callback_info info) 1165{ 1166 napi_value result = nullptr; 1167 initGLES(); 1168 GLuint shader = glCreateShader(GL_VERTEX_SHADER); 1169 if (CREAT_ERROR != shader) { 1170 napi_create_int32(env, SUCCESS, &result); 1171 } else { 1172 napi_create_int32(env, FAILED, &result); 1173 } 1174 glDeleteShader(shader); 1175 destroyGLES(); 1176 return result; 1177} 1178 1179static napi_value GLCreateShaderProgramv(napi_env env, napi_callback_info info) 1180{ 1181 initGLES(); 1182 GLuint shader = glCreateShaderProgramv(GL_VERTEX_SHADER, CREAT_NUM_ONE, &vertexShaderSource); 1183 napi_value result = nullptr; 1184 if (CREAT_ERROR == shader) { 1185 napi_create_int32(env, FAILED, &result); 1186 } else { 1187 napi_create_int32(env, SUCCESS, &result); 1188 } 1189 glDeleteShader(shader); 1190 destroyGLES(); 1191 return result; 1192} 1193 1194static napi_value GLCullFace(napi_env env, napi_callback_info info) 1195{ 1196 initGLES(); 1197 glCullFace(GL_BACK); 1198 GLenum glError = glGetError(); 1199 destroyGLES(); 1200 return getError(env, glError); 1201} 1202 1203static napi_value GLDebugMessageCallback(napi_env env, napi_callback_info info) 1204{ 1205 initGLES(); 1206 glDebugMessageCallback(nullptr, nullptr); 1207 GLenum glError = glGetError(); 1208 destroyGLES(); 1209 return getError(env, glError); 1210} 1211 1212static napi_value GLDebugMessageControl(napi_env env, napi_callback_info info) 1213{ 1214 initGLES(); 1215 glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_OTHER, GL_DEBUG_SEVERITY_LOW, INT_INIT_VAL, nullptr, GL_FALSE); 1216 GLenum glError = glGetError(); 1217 destroyGLES(); 1218 return getError(env, glError); 1219} 1220 1221static napi_value GLDebugMessageInsert(napi_env env, napi_callback_info info) 1222{ 1223 initGLES(); 1224 glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, INT_INIT_VAL, GL_DEBUG_SEVERITY_HIGH, 1225 SUB_DATA_SIZE, "Fragment shader compilation failed"); 1226 GLenum glError = glGetError(); 1227 destroyGLES(); 1228 return getError(env, glError); 1229} 1230 1231static napi_value GLDeleteBuffers(napi_env env, napi_callback_info info) 1232{ 1233 initGLES(); 1234 GLuint buffer = INT_INIT_VAL; 1235 glGenBuffers(CREAT_NUM_ONE, &buffer); 1236 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 1237 GLenum glError = glGetError(); 1238 destroyGLES(); 1239 return getError(env, glError); 1240} 1241 1242static napi_value GLDeleteFramebuffers(napi_env env, napi_callback_info info) 1243{ 1244 initGLES(); 1245 GLuint buffer = INT_INIT_VAL; 1246 glGenFramebuffers(CREAT_NUM_ONE, &buffer); 1247 glDeleteFramebuffers(CREAT_NUM_ONE, &buffer); 1248 GLenum glError = glGetError(); 1249 destroyGLES(); 1250 return getError(env, glError); 1251} 1252 1253static napi_value GLDeleteProgram(napi_env env, napi_callback_info info) 1254{ 1255 initGLES(); 1256 GLuint programObject = glCreateProgram(); 1257 glDeleteProgram(programObject); 1258 GLenum glError = glGetError(); 1259 destroyGLES(); 1260 return getError(env, glError); 1261} 1262 1263static napi_value GLDeleteProgramPipelines(napi_env env, napi_callback_info info) 1264{ 1265 initGLES(); 1266 GLuint pipeline = INT_INIT_VAL; 1267 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 1268 glDeleteProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 1269 GLenum glError = glGetError(); 1270 destroyGLES(); 1271 return getError(env, glError); 1272} 1273 1274static napi_value GLDeleteQueries(napi_env env, napi_callback_info info) 1275{ 1276 initGLES(); 1277 GLuint queryIds = INT_INIT_VAL; 1278 glGenQueries(CREAT_NUM_ONE, &queryIds); 1279 glDeleteQueries(CREAT_NUM_ONE, &queryIds); 1280 GLenum glError = glGetError(); 1281 destroyGLES(); 1282 return getError(env, glError); 1283} 1284 1285static napi_value GLDeleteRenderbuffers(napi_env env, napi_callback_info info) 1286{ 1287 initGLES(); 1288 GLuint rbo = INT_INIT_VAL; 1289 glGenRenderbuffers(CREAT_NUM_ONE, &rbo); 1290 glDeleteRenderbuffers(CREAT_NUM_ONE, &rbo); 1291 GLenum glError = glGetError(); 1292 destroyGLES(); 1293 return getError(env, glError); 1294} 1295 1296static napi_value GLDeleteSamplers(napi_env env, napi_callback_info info) 1297{ 1298 initGLES(); 1299 GLuint sampler = INT_INIT_VAL; 1300 glGenSamplers(CREAT_NUM_ONE, &sampler); 1301 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 1302 GLenum glError = glGetError(); 1303 destroyGLES(); 1304 return getError(env, glError); 1305} 1306 1307static napi_value GLDeleteShader(napi_env env, napi_callback_info info) 1308{ 1309 initGLES(); 1310 GLuint shader = glCreateShader(GL_VERTEX_SHADER); 1311 glDeleteShader(shader); 1312 GLenum glError = glGetError(); 1313 destroyGLES(); 1314 return getError(env, glError); 1315} 1316 1317static napi_value GLDeleteSync(napi_env env, napi_callback_info info) 1318{ 1319 initGLES(); 1320 GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, INT_INIT_VAL); 1321 glClientWaitSync(sync, INT_INIT_VAL, INT_INIT_VAL); 1322 glDeleteSync(sync); 1323 GLenum glError = glGetError(); 1324 destroyGLES(); 1325 return getError(env, glError); 1326} 1327 1328static napi_value GLDeleteTextures(napi_env env, napi_callback_info info) 1329{ 1330 initGLES(); 1331 GLuint texture = INT_INIT_VAL; 1332 glGenTextures(CREAT_NUM_ONE, &texture); 1333 glDeleteTextures(CREAT_NUM_ONE, &texture); 1334 GLenum glError = glGetError(); 1335 destroyGLES(); 1336 return getError(env, glError); 1337} 1338 1339static napi_value GLDeleteTransformFeedbacks(napi_env env, napi_callback_info info) 1340{ 1341 initGLES(); 1342 GLuint transformFeedback = INT_INIT_VAL; 1343 glGenTransformFeedbacks(CREAT_NUM_ONE, &transformFeedback); 1344 glDeleteTransformFeedbacks(CREAT_NUM_ONE, &transformFeedback); 1345 GLenum glError = glGetError(); 1346 destroyGLES(); 1347 return getError(env, glError); 1348} 1349 1350static napi_value GLDeleteVertexArrays(napi_env env, napi_callback_info info) 1351{ 1352 initGLES(); 1353 GLuint vao = INT_INIT_VAL; 1354 glGenVertexArrays(CREAT_NUM_ONE, &vao); 1355 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 1356 GLenum glError = glGetError(); 1357 destroyGLES(); 1358 return getError(env, glError); 1359} 1360 1361static napi_value GLDepthFunc(napi_env env, napi_callback_info info) 1362{ 1363 initGLES(); 1364 glDepthFunc(GL_LEQUAL); 1365 GLenum glError = glGetError(); 1366 destroyGLES(); 1367 return getError(env, glError); 1368} 1369 1370static napi_value GLDepthMask(napi_env env, napi_callback_info info) 1371{ 1372 initGLES(); 1373 glDepthMask(GL_TRUE); 1374 glDepthMask(GL_FALSE); 1375 GLenum glError = glGetError(); 1376 destroyGLES(); 1377 return getError(env, glError); 1378} 1379 1380static napi_value GLDepthRangef(napi_env env, napi_callback_info info) 1381{ 1382 initGLES(); 1383 glDepthRangef(CLEAR_01, CLEAR_10); 1384 GLenum glError = glGetError(); 1385 destroyGLES(); 1386 return getError(env, glError); 1387} 1388static napi_value GLDetachShader(napi_env env, napi_callback_info info) 1389{ 1390 initGLES(); 1391 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 1392 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 1393 GLuint programObject = glCreateProgram(); 1394 glAttachShader(programObject, shaderVertex); 1395 glAttachShader(programObject, shaderFragment); 1396 glLinkProgram(programObject); 1397 glDetachShader(programObject, shaderFragment); 1398 GLenum glError = glGetError(); 1399 glDeleteShader(shaderVertex); 1400 glDeleteShader(shaderFragment); 1401 glDeleteProgram(programObject); 1402 destroyGLES(); 1403 return getError(env, glError); 1404} 1405 1406static napi_value GLDisable(napi_env env, napi_callback_info info) 1407{ 1408 initGLES(); 1409 glEnable(GL_BLEND); 1410 glDisable(GL_BLEND); 1411 GLenum glError = glGetError(); 1412 destroyGLES(); 1413 return getError(env, glError); 1414} 1415 1416static napi_value GLDisablei(napi_env env, napi_callback_info info) 1417{ 1418 initGLES(); 1419 glEnable(GL_BLEND); 1420 glDisablei(GL_BLEND, INT_INIT_VAL); 1421 GLenum glError = glGetError(); 1422 destroyGLES(); 1423 return getError(env, glError); 1424} 1425 1426static napi_value GLDisableVertexAttribArray(napi_env env, napi_callback_info info) 1427{ 1428 initGLES(); 1429 GLuint vao = INT_INIT_VAL, vbo = INT_INIT_VAL; 1430 glGenVertexArrays(CREAT_NUM_ONE, &vao); 1431 glGenBuffers(CREAT_NUM_ONE, &vbo); 1432 glBindVertexArray(vao); 1433 glBindBuffer(GL_ARRAY_BUFFER, vbo); 1434 glEnableVertexAttribArray(INT_INIT_VAL); 1435 glDisableVertexAttribArray(INT_INIT_VAL); 1436 GLenum glError = glGetError(); 1437 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 1438 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 1439 destroyGLES(); 1440 return getError(env, glError); 1441} 1442 1443static napi_value GLDispatchCompute(napi_env env, napi_callback_info info) 1444{ 1445 initGLES(); 1446 GLuint shader = esLoadShader(GL_COMPUTE_SHADER, fragmentShaderSourceCompute); 1447 GLuint program = glCreateProgram(); 1448 glAttachShader(program, shader); 1449 glLinkProgram(program); 1450 GLuint buffer = INT_INIT_VAL; 1451 glGenBuffers(CREAT_NUM_ONE, &buffer); 1452 glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer); 1453 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float) * COMPUTE_VAL, nullptr, GL_STATIC_DRAW); 1454 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, INT_INIT_VAL, buffer); 1455 glUseProgram(program); 1456 glDispatchCompute(COMPUTE_VAL, CREAT_NUM_ONE, CREAT_NUM_ONE); 1457 GLenum glError = glGetError(); 1458 glDeleteShader(shader); 1459 glDeleteProgram(program); 1460 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 1461 destroyGLES(); 1462 return getError(env, glError); 1463} 1464 1465static napi_value GLDispatchComputeIndirect(napi_env env, napi_callback_info info) 1466{ 1467 initGLES(); 1468 typedef struct { 1469 GLuint num_groups_x; 1470 GLuint num_groups_y; 1471 GLuint num_groups_z; 1472 } DispatchIndirectCommand; 1473 DispatchIndirectCommand command = {INT_INIT_VAL}; 1474 command.num_groups_x = COMPUTE_VAL; 1475 command.num_groups_y = CREAT_NUM_ONE; 1476 command.num_groups_z = CREAT_NUM_ONE; 1477 GLuint shader = esLoadShader(GL_COMPUTE_SHADER, fragmentShaderSourceComputeIndirect); 1478 GLuint program = glCreateProgram(); 1479 glAttachShader(program, shader); 1480 glLinkProgram(program); 1481 GLuint indirectCommandBuffer = INT_INIT_VAL; 1482 glGenBuffers(CREAT_NUM_ONE, &indirectCommandBuffer); 1483 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, indirectCommandBuffer); 1484 glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(DispatchIndirectCommand), &command, GL_STATIC_DRAW); 1485 glUseProgram(program); 1486 glDispatchComputeIndirect(INT_INIT_VAL); 1487 GLenum glError = glGetError(); 1488 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT); 1489 glDeleteShader(shader); 1490 glDeleteProgram(program); 1491 glDeleteBuffers(CREAT_NUM_ONE, &indirectCommandBuffer); 1492 destroyGLES(); 1493 return getError(env, glError); 1494} 1495 1496static napi_value GLDrawArrays(napi_env env, napi_callback_info info) 1497{ 1498 initGLES(); 1499 glDrawArrays(GL_TRIANGLES, ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE); 1500 GLenum glError = glGetError(); 1501 destroyGLES(); 1502 return getError(env, glError); 1503} 1504 1505static napi_value GLDrawArraysIndirect(napi_env env, napi_callback_info info) 1506{ 1507 initGLES(); 1508 GLfloat vertices[] = {CLEAR_00, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f}; 1509 typedef struct { 1510 GLuint count; 1511 GLuint primCount; 1512 GLuint first; 1513 GLuint baseInstance; 1514 } DrawArraysIndirectCommand; 1515 DrawArraysIndirectCommand cmd; 1516 cmd.count = ARRAY_INDEX_THREE; 1517 cmd.primCount = CREAT_NUM_ONE; 1518 cmd.first = INT_INIT_VAL; 1519 cmd.baseInstance = INT_INIT_VAL; 1520 GLuint vao = GL_NO_ERROR; 1521 glGenVertexArrays(CREAT_NUM_ONE, &vao); 1522 glBindVertexArray(vao); 1523 GLuint vbo = GL_NO_ERROR; 1524 glGenBuffers(CREAT_NUM_ONE, &vbo); 1525 glBindBuffer(GL_ARRAY_BUFFER, vbo); 1526 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1527 GLuint drawCmdBuf = GL_NO_ERROR; 1528 glGenBuffers(CREAT_NUM_ONE, &drawCmdBuf); 1529 glBindBuffer(GL_DRAW_INDIRECT_BUFFER, drawCmdBuf); 1530 glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(cmd), &cmd, GL_STATIC_DRAW); 1531 glDrawArraysIndirect(GL_TRIANGLES, INT_INIT_VAL); 1532 GLenum glError = glGetError(); 1533 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 1534 glDeleteBuffers(CREAT_NUM_ONE, &drawCmdBuf); 1535 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 1536 destroyGLES(); 1537 return getError(env, glError); 1538} 1539 1540static napi_value GLDrawArraysInstanced(napi_env env, napi_callback_info info) 1541{ 1542 initGLES(); 1543 glDrawArraysInstanced(GL_TRIANGLES, ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE, ARRAY_INDEX_THREE); 1544 GLenum glError = glGetError(); 1545 destroyGLES(); 1546 return getError(env, glError); 1547} 1548 1549static napi_value GLDrawBuffers(napi_env env, napi_callback_info info) 1550{ 1551 initGLES(); 1552 GLuint fbo = INT_INIT_VAL; 1553 glGenFramebuffers(CREAT_NUM_ONE, &fbo); 1554 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1555 GLenum drawBufs[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1}; 1556 glDrawBuffers(ARRAY_INDEX_TWO, drawBufs); 1557 GLenum glError = glGetError(); 1558 glDeleteFramebuffers(CREAT_NUM_ONE, &fbo); 1559 destroyGLES(); 1560 return getError(env, glError); 1561} 1562 1563static napi_value GLDrawElements(napi_env env, napi_callback_info info) 1564{ 1565 initGLES(); 1566 glDrawElements(GL_TRIANGLES, ARRAY_INDEX_TWO, GL_UNSIGNED_SHORT, ARRAY_INDEX_ZERO); 1567 GLenum glError = glGetError(); 1568 destroyGLES(); 1569 return getError(env, glError); 1570} 1571 1572static napi_value GLDrawElementsBaseVertex(napi_env env, napi_callback_info info) 1573{ 1574 initGLES(); 1575 GLuint ibo = INT_INIT_VAL; 1576 GLint baseVertex = ARRAY_INDEX_ZERO; 1577 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); 1578 glDrawElementsBaseVertex(GL_TRIANGLES, ARRAY_INDEX_TWO, GL_UNSIGNED_SHORT, ARRAY_INDEX_ZERO, baseVertex); 1579 GLenum glError = glGetError(); 1580 glBindVertexArray(ARRAY_INDEX_ZERO); 1581 destroyGLES(); 1582 return getError(env, glError); 1583} 1584 1585static napi_value GLDrawElementsIndirect(napi_env env, napi_callback_info info) 1586{ 1587 initGLES(); 1588 GLfloat vertices[] = {CLEAR_00, 0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00, -0.5f, -0.5f, CLEAR_00}; 1589 GLuint indices[] = {0, 1, 2}; 1590 typedef struct { 1591 GLuint count; 1592 GLuint instanceCount; 1593 GLuint firstIndex; 1594 GLuint baseVertex; 1595 GLuint baseInstance; 1596 } DrawElementsIndirectCommand; 1597 DrawElementsIndirectCommand cmd; 1598 GLuint vertexBuffer, indexBuffer, indirectBuffer; 1599 unsigned int VAO; 1600 glGenVertexArrays(CREAT_NUM_ONE, &VAO); 1601 glBindVertexArray(VAO); 1602 glGenBuffers(CREAT_NUM_ONE, &vertexBuffer); 1603 glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); 1604 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1605 glGenBuffers(CREAT_NUM_ONE, &indexBuffer); 1606 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); 1607 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 1608 glGenBuffers(CREAT_NUM_ONE, &indirectBuffer); 1609 cmd.count = ARRAY_INDEX_THREE; 1610 cmd.instanceCount = CREAT_NUM_ONE; 1611 cmd.firstIndex = INT_INIT_VAL; 1612 cmd.baseVertex = INT_INIT_VAL; 1613 cmd.baseInstance = INT_INIT_VAL; 1614 glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuffer); 1615 glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &cmd, GL_STATIC_DRAW); 1616 glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); 1617 glEnableVertexAttribArray(INT_INIT_VAL); 1618 glVertexAttribPointer(INT_INIT_VAL, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, INT_INIT_VAL, INT_INIT_VAL); 1619 glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuffer); 1620 glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, INT_INIT_VAL); 1621 GLenum glError = glGetError(); 1622 glDeleteBuffers(CREAT_NUM_ONE, &vertexBuffer); 1623 glDeleteBuffers(CREAT_NUM_ONE, &indexBuffer); 1624 glDeleteBuffers(CREAT_NUM_ONE, &indirectBuffer); 1625 glDeleteVertexArrays(CREAT_NUM_ONE, &VAO); 1626 destroyGLES(); 1627 return getError(env, glError); 1628} 1629 1630static napi_value GLDrawElementsInstanced(napi_env env, napi_callback_info info) 1631{ 1632 GLenum glError = GL_NO_ERROR; 1633 initGLES(); 1634 GLuint vbo; 1635 GLuint ibo; 1636 GLfloat vertices[] = {-0.5f, CLEAR_00, CLEAR_00, 0.5f, CLEAR_00, CLEAR_00, CLEAR_00, 0.5f, CLEAR_00}; 1637 GLubyte indices[] = {0, 1, 2}; 1638 glGenBuffers(ARRAY_INDEX_ONE, &vbo); 1639 glGenBuffers(ARRAY_INDEX_ONE, &ibo); 1640 glBindBuffer(GL_ARRAY_BUFFER, vbo); 1641 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1642 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); 1643 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 1644 glVertexAttribPointer(ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, ARRAY_INDEX_ZERO, ARRAY_INDEX_ZERO); 1645 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 1646 glDrawElementsInstanced(GL_TRIANGLES, ARRAY_INDEX_THREE, GL_UNSIGNED_BYTE, ARRAY_INDEX_ZERO, ARRAY_INDEX_TWO); 1647 glError = glGetError(); 1648 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 1649 glDeleteBuffers(CREAT_NUM_ONE, &ibo); 1650 destroyGLES(); 1651 return getError(env, glError); 1652} 1653 1654static napi_value GLDrawElementsInstancedBaseVertex(napi_env env, napi_callback_info info) 1655{ 1656 GLenum glError = GL_NO_ERROR; 1657 initGLES(); 1658 GLuint vbo = INT_INIT_VAL; 1659 GLuint ibo = INT_INIT_VAL; 1660 GLfloat vertices[] = {-0.5f, -0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00, CLEAR_00, 0.5f, CLEAR_00}; 1661 GLubyte indices[] = {0, 1, 2}; 1662 glGenBuffers(ARRAY_INDEX_ONE, &vbo); 1663 glGenBuffers(ARRAY_INDEX_ONE, &ibo); 1664 glBindBuffer(GL_ARRAY_BUFFER, vbo); 1665 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1666 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); 1667 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 1668 glVertexAttribPointer(ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, ARRAY_INDEX_ZERO, ARRAY_INDEX_ZERO); 1669 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 1670 glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ARRAY_INDEX_THREE, GL_UNSIGNED_BYTE, ARRAY_INDEX_ZERO, 1671 ARRAY_INDEX_THREE, ARRAY_INDEX_ONE); 1672 glError = glGetError(); 1673 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 1674 glDeleteBuffers(CREAT_NUM_ONE, &ibo); 1675 destroyGLES(); 1676 return getError(env, glError); 1677} 1678 1679static napi_value GLDrawRangeElements(napi_env env, napi_callback_info info) 1680{ 1681 GLenum glError = GL_NO_ERROR; 1682 initGLES(); 1683 GLuint vbo = INT_INIT_VAL; 1684 GLuint ibo = INT_INIT_VAL; 1685 glGenBuffers(CREAT_NUM_ONE, &vbo); 1686 glGenBuffers(CREAT_NUM_ONE, &ibo); 1687 GLfloat vertices[] = {-0.5f, -0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00, CLEAR_00, 0.5f, CLEAR_00}; 1688 glBindBuffer(GL_ARRAY_BUFFER, vbo); 1689 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1690 GLuint indices[] = {ARRAY_INDEX_ZERO, ARRAY_INDEX_ONE, ARRAY_INDEX_TWO}; 1691 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); 1692 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 1693 glVertexAttribPointer(ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, ARRAY_INDEX_ZERO, ARRAY_INDEX_ZERO); 1694 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 1695 glDrawRangeElements(GL_TRIANGLES, ARRAY_INDEX_ONE, ARRAY_INDEX_TWO, ARRAY_INDEX_TWO, GL_UNSIGNED_BYTE, 1696 ARRAY_INDEX_ZERO); 1697 glError = glGetError(); 1698 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 1699 glDeleteBuffers(CREAT_NUM_ONE, &ibo); 1700 destroyGLES(); 1701 return getError(env, glError); 1702} 1703 1704static napi_value GLDrawRangeElementsBaseVertex(napi_env env, napi_callback_info info) 1705{ 1706 GLenum glError = GL_NO_ERROR; 1707 initGLES(); 1708 GLuint vbo = INT_INIT_VAL; 1709 GLuint ibo = INT_INIT_VAL; 1710 GLuint vao = INT_INIT_VAL; 1711 glGenBuffers(ARRAY_INDEX_ONE, &vbo); 1712 glGenBuffers(ARRAY_INDEX_ONE, &ibo); 1713 GLfloat vertices[] = {-0.5f, -0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00, CLEAR_00, 0.5f, CLEAR_00}; 1714 GLuint indices[] = {0, 1, 2}; 1715 glBindVertexArray(vao); 1716 glBindBuffer(GL_ARRAY_BUFFER, vbo); 1717 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1718 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); 1719 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 1720 glVertexAttribPointer(ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, ARRAY_INDEX_ZERO, ARRAY_INDEX_ZERO); 1721 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 1722 glDrawRangeElementsBaseVertex(GL_TRIANGLES, ARRAY_INDEX_ONE, ARRAY_INDEX_TWO, ARRAY_INDEX_TWO, GL_UNSIGNED_INT, 1723 ARRAY_INDEX_ZERO, ARRAY_INDEX_ONE); 1724 glError = glGetError(); 1725 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 1726 glDeleteBuffers(CREAT_NUM_ONE, &ibo); 1727 destroyGLES(); 1728 return getError(env, glError); 1729} 1730 1731static napi_value GLEnable(napi_env env, napi_callback_info info) 1732{ 1733 initGLES(); 1734 glEnable(GL_BLEND); 1735 GLenum glError = glGetError(); 1736 destroyGLES(); 1737 return getError(env, glError); 1738} 1739 1740static napi_value GLEnablei(napi_env env, napi_callback_info info) 1741{ 1742 initGLES(); 1743 glEnablei(GL_BLEND, ARRAY_INDEX_ZERO); 1744 GLenum glError = glGetError(); 1745 glDisablei(GL_BLEND, ARRAY_INDEX_ZERO); 1746 destroyGLES(); 1747 return getError(env, glError); 1748} 1749 1750static napi_value GLEnableVertexAttribArray(napi_env env, napi_callback_info info) 1751{ 1752 initGLES(); 1753 GLfloat vertices[] = {CLEAR_00, 0.5f, CLEAR_00, -0.5f, -0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00}; 1754 GLuint VAO = INT_INIT_VAL; 1755 GLuint VBO = INT_INIT_VAL; 1756 glGenVertexArrays(CREAT_NUM_ONE, &VAO); 1757 glBindVertexArray(VAO); 1758 glGenBuffers(CREAT_NUM_ONE, &VBO); 1759 glBindBuffer(GL_ARRAY_BUFFER, VBO); 1760 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 1761 glVertexAttribPointer(INT_INIT_VAL, ATTRIB_SIZE, GL_FLOAT, GL_FALSE, INT_INIT_VAL, INT_INIT_VAL); 1762 glEnableVertexAttribArray(INT_INIT_VAL); 1763 GLenum glError = glGetError(); 1764 glDeleteBuffers(CREAT_NUM_ONE, &VBO); 1765 glDeleteVertexArrays(CREAT_NUM_ONE, &VAO); 1766 destroyGLES(); 1767 return getError(env, glError); 1768} 1769 1770static napi_value GLEndQuery(napi_env env, napi_callback_info info) 1771{ 1772 initGLES(); 1773 GLuint queryID = INT_INIT_VAL; 1774 glGenQueries(CREAT_NUM_ONE, &queryID); 1775 glBeginQuery(GL_ANY_SAMPLES_PASSED, queryID); 1776 glEndQuery(GL_ANY_SAMPLES_PASSED); 1777 GLenum glError = glGetError(); 1778 glDeleteQueries(CREAT_NUM_ONE, &queryID); 1779 destroyGLES(); 1780 return getError(env, glError); 1781} 1782 1783static napi_value GLEndTransformFeedback(napi_env env, napi_callback_info info) 1784{ 1785 GLenum glError = GL_NO_ERROR; 1786 initGLES(); 1787 GLuint tfBuffer = INT_INIT_VAL; 1788 glGenBuffers(CREAT_NUM_ONE, &tfBuffer); 1789 GLuint vao = INT_INIT_VAL; 1790 glGenVertexArrays(CREAT_NUM_ONE, &vao); 1791 glBindVertexArray(vao); 1792 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 1793 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 1794 GLuint programObject = glCreateProgram(); 1795 glAttachShader(programObject, shaderVertex); 1796 glAttachShader(programObject, shaderFragment); 1797 glLinkProgram(programObject); 1798 glUseProgram(programObject); 1799 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, INT_INIT_VAL, tfBuffer); 1800 glTransformFeedbackVaryings(programObject, VARYING_NUM, (const char *[]){"gl_Position", "vColor"}, 1801 GL_SEPARATE_ATTRIBS); 1802 glEnable(GL_RASTERIZER_DISCARD); 1803 glBeginTransformFeedback(GL_POINTS); 1804 glEndTransformFeedback(); 1805 glError = glGetError(); 1806 glDeleteShader(shaderVertex); 1807 glDeleteShader(shaderFragment); 1808 glDeleteProgram(programObject); 1809 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 1810 destroyGLES(); 1811 return getError(env, glError); 1812} 1813 1814static napi_value GLFenceSync(napi_env env, napi_callback_info info) 1815{ 1816 initGLES(); 1817 glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, ARRAY_INDEX_ZERO); 1818 GLenum glError = glGetError(); 1819 destroyGLES(); 1820 return getError(env, glError); 1821} 1822 1823static napi_value GLFinish(napi_env env, napi_callback_info info) 1824{ 1825 initGLES(); 1826 glClearColor(INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 1827 glClear(GL_COLOR_BUFFER_BIT); 1828 glFinish(); 1829 GLenum glError = glGetError(); 1830 destroyGLES(); 1831 return getError(env, glError); 1832} 1833 1834static napi_value GLFlush(napi_env env, napi_callback_info info) 1835{ 1836 initGLES(); 1837 glClearColor(INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 1838 glClear(GL_COLOR_BUFFER_BIT); 1839 glFlush(); 1840 GLenum glError = glGetError(); 1841 destroyGLES(); 1842 return getError(env, glError); 1843} 1844 1845static napi_value GLFlushMappedBufferRange(napi_env env, napi_callback_info info) 1846{ 1847 initGLES(); 1848 GLuint buffer = INT_INIT_VAL; 1849 glGenBuffers(CREAT_NUM_ONE, &buffer); 1850 glBindBuffer(GL_ARRAY_BUFFER, buffer); 1851 glBufferData(GL_ARRAY_BUFFER, GL_BUF_SIZE, nullptr, GL_DYNAMIC_DRAW); 1852 glMapBufferRange(GL_ARRAY_BUFFER, INT_INIT_VAL, GL_BUF_SIZE, 1853 GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 1854 1855 glFlushMappedBufferRange(GL_ARRAY_BUFFER, INT_INIT_VAL, GL_BUF_SIZE); 1856 GLenum glError = glGetError(); 1857 glUnmapBuffer(GL_ARRAY_BUFFER); 1858 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 1859 destroyGLES(); 1860 return getError(env, glError); 1861} 1862 1863static napi_value GLFramebufferParameteri(napi_env env, napi_callback_info info) 1864{ 1865 initGLES(); 1866 GLuint framebuffer = INT_INIT_VAL; 1867 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 1868 1869 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 1870 glFramebufferParameteri(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, INIT_HEIGHT); 1871 GLenum glError = glGetError(); 1872 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 1873 destroyGLES(); 1874 return getError(env, glError); 1875} 1876 1877static napi_value GLFramebufferRenderbuffer(napi_env env, napi_callback_info info) 1878{ 1879 initGLES(); 1880 GLuint framebuffer; 1881 GLuint renderbuffer; 1882 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 1883 glGenRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 1884 1885 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); 1886 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, INIT_HEIGHT, INIT_WIDTH); 1887 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 1888 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderbuffer); 1889 1890 GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); 1891 napi_value result = nullptr; 1892 if (status == GL_FRAMEBUFFER_COMPLETE) { 1893 napi_create_int32(env, SUCCESS, &result); 1894 } else { 1895 napi_create_int32(env, FAILED, &result); 1896 } 1897 1898 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 1899 glDeleteRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 1900 destroyGLES(); 1901 return result; 1902} 1903 1904static napi_value GLFramebufferTexture(napi_env env, napi_callback_info info) 1905{ 1906 initGLES(); 1907 GLuint texture = INT_INIT_VAL; 1908 glGenTextures(CREAT_NUM_ONE, &texture); 1909 glBindTexture(GL_TEXTURE_2D, texture); 1910 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, INIT_HEIGHT, INIT_WIDTH, INT_INIT_VAL, GL_RGB, GL_UNSIGNED_BYTE, 1911 nullptr); 1912 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1913 1914 GLuint framebuffer = INT_INIT_VAL; 1915 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 1916 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 1917 1918 glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture, INT_INIT_VAL); 1919 GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); 1920 1921 napi_value result = nullptr; 1922 if (status == GL_FRAMEBUFFER_COMPLETE) { 1923 napi_create_int32(env, SUCCESS, &result); 1924 } else { 1925 napi_create_int32(env, FAILED, &result); 1926 } 1927 1928 glDeleteFramebuffers(INFO_LEN_ONE, &framebuffer); 1929 glDeleteTextures(INFO_LEN_ONE, &texture); 1930 destroyGLES(); 1931 return result; 1932} 1933 1934static napi_value GLFramebufferTexture2D(napi_env env, napi_callback_info info) 1935{ 1936 initGLES(); 1937 GLuint texture = INT_INIT_VAL; 1938 glGenTextures(CREAT_NUM_ONE, &texture); 1939 glBindTexture(GL_TEXTURE_2D, texture); 1940 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, INIT_WIDTH, INIT_WIDTH, INT_INIT_VAL, GL_RGB, GL_UNSIGNED_BYTE, 1941 nullptr); 1942 1943 GLuint framebuffer = INT_INIT_VAL; 1944 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 1945 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 1946 1947 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, INT_INIT_VAL); 1948 GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); 1949 napi_value result = nullptr; 1950 if (status == GL_FRAMEBUFFER_COMPLETE) { 1951 napi_create_int32(env, SUCCESS, &result); 1952 } else { 1953 napi_create_int32(env, FAILED, &result); 1954 } 1955 glDeleteFramebuffers(INFO_LEN_ONE, &framebuffer); 1956 glDeleteTextures(INFO_LEN_ONE, &texture); 1957 destroyGLES(); 1958 return result; 1959} 1960 1961static napi_value GLFramebufferTextureLayer(napi_env env, napi_callback_info info) 1962{ 1963 initGLES(); 1964 GLuint texture = INT_INIT_VAL; 1965 glGenTextures(CREAT_NUM_ONE, &texture); 1966 glBindTexture(GL_TEXTURE_2D_ARRAY, texture); 1967 glTexStorage3D(GL_TEXTURE_2D_ARRAY, IMAGE2D_LEVEL_ONE, GL_RGBA8, INIT_WIDTH, INIT_HEIGHT, VARYING_NUM); 1968 1969 GLuint framebuffer = INT_INIT_VAL; 1970 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 1971 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 1972 1973 glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture, INT_INIT_VAL, INT_INIT_VAL); 1974 GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); 1975 1976 napi_value result = nullptr; 1977 if (status == GL_FRAMEBUFFER_COMPLETE) { 1978 napi_create_int32(env, SUCCESS, &result); 1979 } else { 1980 napi_create_int32(env, FAILED, &result); 1981 } 1982 glDeleteFramebuffers(INFO_LEN_ONE, &framebuffer); 1983 glDeleteTextures(CREAT_NUM_ONE, &texture); 1984 destroyGLES(); 1985 return result; 1986} 1987 1988static napi_value GLFrontFace(napi_env env, napi_callback_info info) 1989{ 1990 initGLES(); 1991 glClearColor(CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10); 1992 glClear(GL_COLOR_BUFFER_BIT); 1993 glFrontFace(GL_CW); 1994 GLenum glError = glGetError(); 1995 destroyGLES(); 1996 return getError(env, glError); 1997} 1998 1999static napi_value GLGenBuffers(napi_env env, napi_callback_info info) 2000{ 2001 initGLES(); 2002 GLuint buffer = INT_INIT_VAL; 2003 glGenBuffers(CREAT_NUM_ONE, &buffer); 2004 GLenum glError = glGetError(); 2005 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 2006 destroyGLES(); 2007 return getError(env, glError); 2008} 2009 2010static napi_value GLGenerateMipmap(napi_env env, napi_callback_info info) 2011{ 2012 initGLES(); 2013 unsigned char pixels[] = {255, 255, 255, 0, 0, 0, 255, 255, 255, 0, 0, 0}; 2014 GLuint texture; 2015 glGenTextures(CREAT_NUM_ONE, &texture); 2016 glBindTexture(GL_TEXTURE_2D, texture); 2017 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, VARYING_NUM, VARYING_NUM, INT_INIT_VAL, GL_RGB, GL_UNSIGNED_BYTE, 2018 pixels); 2019 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); 2020 2021 glGenerateMipmap(GL_TEXTURE_2D); 2022 GLenum glError = glGetError(); 2023 glDeleteTextures(CREAT_NUM_ONE, &texture); 2024 destroyGLES(); 2025 return getError(env, glError); 2026} 2027 2028static napi_value GLGenFramebuffers(napi_env env, napi_callback_info info) 2029{ 2030 initGLES(); 2031 GLuint framebuffer = INT_INIT_VAL; 2032 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 2033 GLenum glError = glGetError(); 2034 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 2035 destroyGLES(); 2036 return getError(env, glError); 2037} 2038 2039static napi_value GLGenProgramPipelines(napi_env env, napi_callback_info info) 2040{ 2041 initGLES(); 2042 GLuint pipeline = INT_INIT_VAL; 2043 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 2044 GLenum glError = glGetError(); 2045 glDeleteProgramPipelines(CREAT_NUM_ONE, &pipeline); 2046 destroyGLES(); 2047 return getError(env, glError); 2048} 2049 2050static napi_value GLGenQueries(napi_env env, napi_callback_info info) 2051{ 2052 initGLES(); 2053 GLuint query = INT_INIT_VAL; 2054 glGenQueries(CREAT_NUM_ONE, &query); 2055 GLenum glError = glGetError(); 2056 glDeleteQueries(CREAT_NUM_ONE, &query); 2057 destroyGLES(); 2058 return getError(env, glError); 2059} 2060 2061static napi_value GLGenRenderbuffers(napi_env env, napi_callback_info info) 2062{ 2063 initGLES(); 2064 GLuint renderbuffer = INT_INIT_VAL; 2065 glGenRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 2066 GLenum glError = glGetError(); 2067 glDeleteRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 2068 destroyGLES(); 2069 return getError(env, glError); 2070} 2071 2072static napi_value GLGenSamplers(napi_env env, napi_callback_info info) 2073{ 2074 initGLES(); 2075 GLuint sampler = INT_INIT_VAL; 2076 glGenSamplers(CREAT_NUM_ONE, &sampler); 2077 GLenum glError = glGetError(); 2078 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 2079 2080 destroyGLES(); 2081 return getError(env, glError); 2082} 2083 2084static napi_value GLGenTextures(napi_env env, napi_callback_info info) 2085{ 2086 initGLES(); 2087 GLuint texture = INT_INIT_VAL; 2088 glGenTextures(CREAT_NUM_ONE, &texture); 2089 GLenum glError = glGetError(); 2090 glDeleteTextures(CREAT_NUM_ONE, &texture); 2091 destroyGLES(); 2092 return getError(env, glError); 2093} 2094 2095static napi_value GLGenTransformFeedbacks(napi_env env, napi_callback_info info) 2096{ 2097 initGLES(); 2098 GLuint transformFeedback; 2099 glGenTransformFeedbacks(CREAT_NUM_ONE, &transformFeedback); 2100 GLenum glError = glGetError(); 2101 glDeleteTextures(CREAT_NUM_ONE, &transformFeedback); 2102 destroyGLES(); 2103 return getError(env, glError); 2104} 2105 2106static napi_value GLGenVertexArrays(napi_env env, napi_callback_info info) 2107{ 2108 initGLES(); 2109 GLuint vertex; 2110 glGenVertexArrays(CREAT_NUM_ONE, &vertex); 2111 GLenum glError = glGetError(); 2112 glDeleteVertexArrays(CREAT_NUM_ONE, &vertex); 2113 destroyGLES(); 2114 return getError(env, glError); 2115} 2116 2117static napi_value GLGetActiveAttrib(napi_env env, napi_callback_info info) 2118{ 2119 initGLES(); 2120 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2121 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2122 GLuint programObjectRed = glCreateProgram(); 2123 glAttachShader(programObjectRed, shaderVertex); 2124 glAttachShader(programObjectRed, shaderFragment); 2125 glLinkProgram(programObjectRed); 2126 glUseProgram(programObjectRed); 2127 2128 GLint numAttribs = INT_INIT_VAL; 2129 glGetProgramiv(programObjectRed, GL_ACTIVE_ATTRIBUTES, &numAttribs); 2130 if (numAttribs == INT_INIT_VAL) { 2131 napi_value result = nullptr; 2132 napi_create_int32(env, FAILED, &result); 2133 return result; 2134 } 2135 char name[GL_BUF_SIZE]; 2136 glGetActiveAttrib(programObjectRed, INT_INIT_VAL, GL_BUF_SIZE, nullptr, nullptr, nullptr, name); 2137 GLenum glError = glGetError(); 2138 2139 glDeleteShader(shaderVertex); 2140 glDeleteShader(shaderFragment); 2141 glDeleteProgram(programObjectRed); 2142 destroyGLES(); 2143 return getError(env, glError); 2144} 2145 2146static napi_value GLGetAttachedShaders(napi_env env, napi_callback_info info) 2147{ 2148 initGLES(); 2149 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2150 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2151 GLuint programObjectRed = glCreateProgram(); 2152 glAttachShader(programObjectRed, shaderVertex); 2153 glAttachShader(programObjectRed, shaderFragment); 2154 glLinkProgram(programObjectRed); 2155 glUseProgram(programObjectRed); 2156 2157 GLint shaderCount; 2158 glGetProgramiv(programObjectRed, GL_ATTACHED_SHADERS, &shaderCount); 2159 GLuint *shaders = (GLuint *)malloc(shaderCount * sizeof(GLuint)); 2160 glGetAttachedShaders(programObjectRed, shaderCount, nullptr, shaders); 2161 GLenum glError = glGetError(); 2162 glDeleteShader(shaderVertex); 2163 glDeleteShader(shaderFragment); 2164 glDeleteProgram(programObjectRed); 2165 free(shaders); 2166 destroyGLES(); 2167 return getError(env, glError); 2168} 2169 2170static napi_value GLGetAttribLocation(napi_env env, napi_callback_info info) 2171{ 2172 initGLES(); 2173 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2174 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2175 GLuint programObjectRed = glCreateProgram(); 2176 glAttachShader(programObjectRed, shaderVertex); 2177 glAttachShader(programObjectRed, shaderFragment); 2178 glLinkProgram(programObjectRed); 2179 glUseProgram(programObjectRed); 2180 2181 glGetAttribLocation(programObjectRed, "vPosition"); 2182 GLenum glError = glGetError(); 2183 glDeleteShader(shaderVertex); 2184 glDeleteShader(shaderFragment); 2185 glDeleteProgram(programObjectRed); 2186 destroyGLES(); 2187 return getError(env, glError); 2188} 2189 2190static napi_value GLGetBooleani_v(napi_env env, napi_callback_info info) 2191{ 2192 initGLES(); 2193 GLint max = INT_INIT_VAL; 2194 glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max); 2195 GLboolean attachments[max]; 2196 glGetBooleani_v(GL_COLOR_WRITEMASK, INT_INIT_VAL, attachments); 2197 GLenum glError = glGetError(); 2198 destroyGLES(); 2199 return getError(env, glError); 2200} 2201 2202static napi_value GLGetBooleanv(napi_env env, napi_callback_info info) 2203{ 2204 initGLES(); 2205 GLboolean val = INT_INIT_VAL; 2206 glGetBooleanv(GL_DEPTH_WRITEMASK, &val); 2207 GLenum glError = glGetError(); 2208 destroyGLES(); 2209 return getError(env, glError); 2210} 2211 2212static napi_value GLGetBufferParameteri64v(napi_env env, napi_callback_info info) 2213{ 2214 initGLES(); 2215 GLuint buffer = INT_INIT_VAL; 2216 GLint64 bufferSize = INT_INIT_VAL; 2217 glGenBuffers(CREAT_NUM_ONE, &buffer); 2218 glBindBuffer(GL_ARRAY_BUFFER, buffer); 2219 glGetBufferParameteri64v(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &bufferSize); 2220 GLenum glError = glGetError(); 2221 2222 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 2223 destroyGLES(); 2224 return getError(env, glError); 2225} 2226 2227static napi_value GLGetBufferParameteriv(napi_env env, napi_callback_info info) 2228{ 2229 initGLES(); 2230 GLuint buffer = INT_INIT_VAL; 2231 GLint bufferUsage = INT_INIT_VAL; 2232 glGenBuffers(CREAT_NUM_ONE, &buffer); 2233 glBindBuffer(GL_ARRAY_BUFFER, buffer); 2234 glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_USAGE, &bufferUsage); 2235 GLenum glError = glGetError(); 2236 2237 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 2238 destroyGLES(); 2239 return getError(env, glError); 2240} 2241 2242static napi_value GLGetBufferPointerv(napi_env env, napi_callback_info info) 2243{ 2244 initGLES(); 2245 GLuint buffer = INT_INIT_VAL; 2246 GLvoid *bufferPtr = nullptr; 2247 glGenBuffers(CREAT_NUM_ONE, &buffer); 2248 glBindBuffer(GL_ARRAY_BUFFER, buffer); 2249 glGetBufferPointerv(GL_ARRAY_BUFFER, GL_BUFFER_MAP_POINTER, &bufferPtr); 2250 GLenum glError = glGetError(); 2251 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 2252 destroyGLES(); 2253 return getError(env, glError); 2254} 2255 2256static napi_value GLGetDebugMessageLog(napi_env env, napi_callback_info info) 2257{ 2258 initGLES(); 2259 GLuint count = COUNT_NUM; 2260 GLenum source = INT_INIT_VAL; 2261 GLenum type = INT_INIT_VAL; 2262 GLuint id = INT_INIT_VAL; 2263 GLenum severity = INT_INIT_VAL; 2264 GLsizei length = INT_INIT_VAL; 2265 GLchar messageLog[GL_BUF_SIZE]; 2266 GLuint countSize = GL_BUF_SIZE; 2267 glEnable(GL_DEBUG_OUTPUT); 2268 glGetDebugMessageLog(count, countSize, &source, &type, &id, &severity, &length, messageLog); 2269 2270 GLenum glError = glGetError(); 2271 destroyGLES(); 2272 return getError(env, glError); 2273} 2274 2275static napi_value GLGetError(napi_env env, napi_callback_info info) 2276{ 2277 initGLES(); 2278 GLenum glError = glGetError(); 2279 destroyGLES(); 2280 return getError(env, glError); 2281} 2282 2283static napi_value GLGetFloatv(napi_env env, napi_callback_info info) 2284{ 2285 initGLES(); 2286 GLfloat currentLineWidth; 2287 glLineWidth(CLEAR_50); 2288 glGetFloatv(GL_LINE_WIDTH, ¤tLineWidth); 2289 GLenum glError = glGetError(); 2290 destroyGLES(); 2291 return getError(env, glError); 2292} 2293 2294static napi_value GLGetFragDataLocation(napi_env env, napi_callback_info info) 2295{ 2296 initGLES(); 2297 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2298 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2299 GLuint programObjectRed = glCreateProgram(); 2300 glAttachShader(programObjectRed, shaderVertex); 2301 glAttachShader(programObjectRed, shaderFragment); 2302 glLinkProgram(programObjectRed); 2303 glUseProgram(programObjectRed); 2304 2305 glGetFragDataLocation(programObjectRed, "fragColor"); 2306 GLenum glError = glGetError(); 2307 glDeleteShader(shaderVertex); 2308 glDeleteShader(shaderFragment); 2309 glDeleteProgram(programObjectRed); 2310 destroyGLES(); 2311 return getError(env, glError); 2312} 2313 2314static napi_value GLGetFramebufferAttachmentParameteriv(napi_env env, napi_callback_info info) 2315{ 2316 initGLES(); 2317 GLuint framebuffer = INT_INIT_VAL; 2318 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 2319 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 2320 GLint param = INT_INIT_VAL; 2321 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 2322 ¶m); 2323 GLenum glError = glGetError(); 2324 2325 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 2326 destroyGLES(); 2327 return getError(env, glError); 2328} 2329 2330static napi_value GLGetFramebufferParameteriv(napi_env env, napi_callback_info info) 2331{ 2332 initGLES(); 2333 GLuint framebuffer = INT_INIT_VAL; 2334 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 2335 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 2336 GLint param = INT_INIT_VAL; 2337 glGetFramebufferParameteriv(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, ¶m); 2338 GLenum glError = glGetError(); 2339 2340 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 2341 destroyGLES(); 2342 return getError(env, glError); 2343} 2344 2345static napi_value GLGetGraphicsResetStatus(napi_env env, napi_callback_info info) 2346{ 2347 initGLES(); 2348 napi_value result = nullptr; 2349 GLenum resetStatus = glGetGraphicsResetStatus(); 2350 if (resetStatus == GL_NO_ERROR || resetStatus == GL_GUILTY_CONTEXT_RESET || 2351 resetStatus == GL_INNOCENT_CONTEXT_RESET || resetStatus == GL_UNKNOWN_CONTEXT_RESET) { 2352 napi_create_int32(env, SUCCESS, &result); 2353 } else { 2354 napi_create_int32(env, FAILED, &result); 2355 } 2356 destroyGLES(); 2357 return result; 2358} 2359 2360static napi_value GLGetInteger64i_v(napi_env env, napi_callback_info info) 2361{ 2362 initGLES(); 2363 GLuint buffer = INT_INIT_VAL; 2364 glGenBuffers(CREAT_NUM_ONE, &buffer); 2365 glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer); 2366 GLint64 bufferSize = INT_INIT_VAL; 2367 glGetInteger64i_v(GL_SHADER_STORAGE_BUFFER_SIZE, buffer, &bufferSize); 2368 GLenum glError = glGetError(); 2369 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 2370 destroyGLES(); 2371 return getError(env, glError); 2372} 2373 2374static napi_value GLGetInteger64v(napi_env env, napi_callback_info info) 2375{ 2376 initGLES(); 2377 GLint64 value = INT_INIT_VAL; 2378 glGetInteger64v(GL_MAX_TEXTURE_SIZE, &value); 2379 GLenum glError = glGetError(); 2380 return getError(env, glError); 2381} 2382 2383static napi_value GLGetIntegeri_v(napi_env env, napi_callback_info info) 2384{ 2385 initGLES(); 2386 GLint index = INT_INIT_VAL; 2387 glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, INT_INIT_VAL, &index); 2388 GLenum glError = glGetError(); 2389 destroyGLES(); 2390 return getError(env, glError); 2391} 2392 2393static napi_value GLGetIntegerv(napi_env env, napi_callback_info info) 2394{ 2395 initGLES(); 2396 GLint max = INT_INIT_VAL; 2397 glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max); 2398 GLenum glError = glGetError(); 2399 destroyGLES(); 2400 return getError(env, glError); 2401} 2402 2403static napi_value GLGetInternalformativ(napi_env env, napi_callback_info info) 2404{ 2405 initGLES(); 2406 GLint numFormats = INT_INIT_VAL; 2407 glGetInternalformativ(GL_RENDERBUFFER, GL_RGB, GL_NUM_SAMPLE_COUNTS, COUNT_NUM, &numFormats); 2408 GLenum glError = glGetError(); 2409 destroyGLES(); 2410 return getError(env, glError); 2411} 2412 2413static napi_value GLGetMultisamplefv(napi_env env, napi_callback_info info) 2414{ 2415 initGLES(); 2416 GLuint framebuffer = INT_INIT_VAL; 2417 GLuint renderbuffer = INT_INIT_VAL; 2418 GLuint texture = INT_INIT_VAL; 2419 glGenRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 2420 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); 2421 glRenderbufferStorageMultisample(GL_RENDERBUFFER, SAMPLES, GL_DEPTH_COMPONENT24, IMAGE_WIDTH, IMAGE_HEIGHT); 2422 2423 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 2424 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer); 2425 glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, INT_INIT_VAL); 2426 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderbuffer); 2427 GLfloat samplePositions[8][2]; 2428 glGetMultisamplefv(GL_SAMPLE_POSITION, INT_INIT_VAL, &samplePositions[0][0]); 2429 GLenum glError = glGetError(); 2430 2431 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 2432 glDeleteRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 2433 destroyGLES(); 2434 return getError(env, glError); 2435} 2436 2437static napi_value GLGetObjectLabel(napi_env env, napi_callback_info info) 2438{ 2439 initGLES(); 2440 GLuint vertexShader = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2441 glObjectLabel(GL_SHADER, vertexShader, FAILED, "Vertex Shader"); 2442 GLsizei len; 2443 glGetObjectLabel(GL_SHADER, vertexShader, GL_MAX_LABEL_LENGTH, &len, nullptr); 2444 char label[len]; 2445 glGetObjectLabel(GL_SHADER, vertexShader, len, nullptr, label); 2446 GLenum glError = glGetError(); 2447 glDeleteShader(vertexShader); 2448 destroyGLES(); 2449 return getError(env, glError); 2450} 2451 2452static napi_value GLGetObjectPtrLabel(napi_env env, napi_callback_info info) 2453{ 2454 initGLES(); 2455 GLsync syncObject = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, INT_INIT_VAL); 2456 GLsizei outLen = INT_INIT_VAL; 2457 glGetObjectPtrLabel(syncObject, INT_INIT_VAL, &outLen, nullptr); 2458 GLenum glError = glGetError(); 2459 glDeleteSync(syncObject); 2460 destroyGLES(); 2461 return getError(env, glError); 2462} 2463 2464static napi_value GLGetPointerv(napi_env env, napi_callback_info info) 2465{ 2466 initGLES(); 2467 GLvoid *params = nullptr; 2468 glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM, ¶ms); 2469 GLenum glError = glGetError(); 2470 destroyGLES(); 2471 return getError(env, glError); 2472} 2473 2474static napi_value GLGetProgramBinary(napi_env env, napi_callback_info info) 2475{ 2476 initGLES(); 2477 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2478 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2479 GLuint program = glCreateProgram(); 2480 glObjectLabel(GL_SHADER, shaderVertex, FAILED, "Vertex Shader"); 2481 2482 glAttachShader(program, shaderVertex); 2483 glAttachShader(program, shaderFragment); 2484 glLinkProgram(program); 2485 2486 GLint binaryLength = INT_INIT_VAL; 2487 glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength); 2488 GLubyte *binary = (GLubyte *)malloc(binaryLength); 2489 GLenum binaryFormat = INT_INIT_VAL; 2490 GLsizei length = INT_INIT_VAL; 2491 glGetProgramBinary(program, binaryLength, &length, &binaryFormat, binary); 2492 GLenum glError = glGetError(); 2493 free(binary); 2494 glDeleteShader(shaderVertex); 2495 glDeleteShader(shaderFragment); 2496 glDeleteProgram(program); 2497 destroyGLES(); 2498 return getError(env, glError); 2499} 2500 2501static napi_value GLGetProgramInfoLog(napi_env env, napi_callback_info info) 2502{ 2503 initGLES(); 2504 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2505 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2506 GLuint program = glCreateProgram(); 2507 glAttachShader(program, shaderVertex); 2508 glAttachShader(program, shaderFragment); 2509 glLinkProgram(program); 2510 2511 char log[] = "My program log"; 2512 glObjectLabel(GL_PROGRAM, program, sizeof(log), log); 2513 2514 GLint length; 2515 glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); 2516 GLchar outLog[length]; 2517 glGetProgramInfoLog(program, length, nullptr, outLog); 2518 GLenum glError = glGetError(); 2519 2520 glDeleteShader(shaderVertex); 2521 glDeleteShader(shaderFragment); 2522 glDeleteProgram(program); 2523 destroyGLES(); 2524 return getError(env, glError); 2525} 2526 2527static napi_value GLGetProgramInterfaceiv(napi_env env, napi_callback_info info) 2528{ 2529 initGLES(); 2530 GLuint program = glCreateProgram(); 2531 GLint numInterfaces; 2532 glGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_ACTIVE_RESOURCES, &numInterfaces); 2533 GLenum glError = glGetError(); 2534 2535 glDeleteProgram(program); 2536 destroyGLES(); 2537 return getError(env, glError); 2538} 2539 2540static napi_value GLGetProgramiv(napi_env env, napi_callback_info info) 2541{ 2542 initGLES(); 2543 GLuint program = glCreateProgram(); 2544 glLinkProgram(program); 2545 GLint length; 2546 glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); 2547 GLenum glError = glGetError(); 2548 glDeleteProgram(program); 2549 destroyGLES(); 2550 return getError(env, glError); 2551} 2552 2553static napi_value GLGetProgramPipelineiv(napi_env env, napi_callback_info info) 2554{ 2555 initGLES(); 2556 GLuint pipeline = INT_INIT_VAL; 2557 glGenProgramPipelines(CREAT_NUM_ONE, &pipeline); 2558 GLint param = INT_INIT_VAL; 2559 glGetProgramPipelineiv(pipeline, GL_ACTIVE_PROGRAM, ¶m); 2560 GLenum glError = glGetError(); 2561 glDeleteProgramPipelines(CREAT_NUM_ONE, &pipeline); 2562 destroyGLES(); 2563 return getError(env, glError); 2564} 2565 2566static napi_value GLGetProgramResourceIndex(napi_env env, napi_callback_info info) 2567{ 2568 initGLES(); 2569 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2570 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2571 GLuint program = glCreateProgram(); 2572 glAttachShader(program, shaderVertex); 2573 glAttachShader(program, shaderFragment); 2574 glLinkProgram(program); 2575 2576 glGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "vPosition"); 2577 GLenum glError = glGetError(); 2578 2579 glDeleteShader(shaderVertex); 2580 glDeleteShader(shaderFragment); 2581 glDeleteProgram(program); 2582 destroyGLES(); 2583 return getError(env, glError); 2584} 2585 2586static napi_value GLGetProgramResourceiv(napi_env env, napi_callback_info info) 2587{ 2588 initGLES(); 2589 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2590 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2591 GLuint program = glCreateProgram(); 2592 glAttachShader(program, shaderVertex); 2593 glAttachShader(program, shaderFragment); 2594 glLinkProgram(program); 2595 2596 GLint numAttrs = INT_INIT_VAL; 2597 glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &numAttrs); 2598 GLenum properties[] = {GL_NAME_LENGTH, GL_TYPE, GL_LOCATION}; 2599 GLuint index = glGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "vPosition"); 2600 2601 napi_value result; 2602 if (index != GL_INVALID_INDEX) { 2603 GLint values[GL_BUF_SIZE]; 2604 GLsizei length = INT_INIT_VAL; 2605 glGetProgramResourceiv(program, GL_PROGRAM_INPUT, index, VERTEX_NUM, properties, GL_BUF_SIZE, &length, values); 2606 GLenum glError = glGetError(); 2607 result = getError(env, glError); 2608 2609 } else { 2610 napi_create_int32(env, FAILED, &result); 2611 } 2612 glDeleteShader(shaderVertex); 2613 glDeleteShader(shaderFragment); 2614 glDeleteProgram(program); 2615 destroyGLES(); 2616 return result; 2617} 2618 2619static napi_value GLGetProgramResourceLocation(napi_env env, napi_callback_info info) 2620{ 2621 initGLES(); 2622 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2623 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2624 GLuint program = glCreateProgram(); 2625 glAttachShader(program, shaderVertex); 2626 glAttachShader(program, shaderFragment); 2627 glLinkProgram(program); 2628 2629 glGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "vPosition"); 2630 GLenum glError = glGetError(); 2631 2632 glDeleteShader(shaderVertex); 2633 glDeleteShader(shaderFragment); 2634 glDeleteProgram(program); 2635 destroyGLES(); 2636 return getError(env, glError); 2637} 2638 2639static napi_value GLGetProgramResourceName(napi_env env, napi_callback_info info) 2640{ 2641 initGLES(); 2642 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2643 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2644 GLuint program = glCreateProgram(); 2645 glAttachShader(program, shaderVertex); 2646 glAttachShader(program, shaderFragment); 2647 glLinkProgram(program); 2648 2649 GLsizei length = INT_INIT_VAL; 2650 char name[GL_BUF_SIZE]; 2651 glGetProgramResourceName(program, GL_PROGRAM_INPUT, INT_INIT_VAL, GL_BUF_SIZE, &length, name); 2652 GLenum glError = glGetError(); 2653 2654 glDeleteShader(shaderVertex); 2655 glDeleteShader(shaderFragment); 2656 glDeleteProgram(program); 2657 destroyGLES(); 2658 return getError(env, glError); 2659} 2660 2661static napi_value GLGetQueryiv(napi_env env, napi_callback_info info) 2662{ 2663 initGLES(); 2664 GLuint query = INT_INIT_VAL; 2665 glGenQueries(CREAT_NUM_ONE, &query); 2666 glBeginQuery(GL_ANY_SAMPLES_PASSED, query); 2667 glEndQuery(GL_ANY_SAMPLES_PASSED); 2668 GLint available = INT_INIT_VAL; 2669 glGetQueryiv(GL_ANY_SAMPLES_PASSED, GL_CURRENT_QUERY, &available); 2670 GLenum glError = glGetError(); 2671 2672 glDeleteQueries(CREAT_NUM_ONE, &query); 2673 destroyGLES(); 2674 return getError(env, glError); 2675} 2676 2677static napi_value GLGetQueryObjectuiv(napi_env env, napi_callback_info info) 2678{ 2679 initGLES(); 2680 GLuint query = INT_INIT_VAL; 2681 glGenQueries(CREAT_NUM_ONE, &query); 2682 glBeginQuery(GL_ANY_SAMPLES_PASSED, query); 2683 glEndQuery(GL_ANY_SAMPLES_PASSED); 2684 GLint available = INT_INIT_VAL; 2685 glGetQueryObjectuiv(query, GL_QUERY_RESULT_AVAILABLE, (GLuint *)&available); 2686 GLenum glError = glGetError(); 2687 2688 glDeleteQueries(CREAT_NUM_ONE, &query); 2689 destroyGLES(); 2690 return getError(env, glError); 2691} 2692 2693static napi_value GLGetRenderbufferParameteriv(napi_env env, napi_callback_info info) 2694{ 2695 initGLES(); 2696 GLuint renderbuffer; 2697 glGenRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 2698 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); 2699 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, INIT_WIDTH, INIT_HEIGHT); 2700 GLint width; 2701 glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &width); 2702 GLenum glError = glGetError(); 2703 glDeleteRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 2704 destroyGLES(); 2705 return getError(env, glError); 2706} 2707 2708static napi_value GLGetSamplerParameterfv(napi_env env, napi_callback_info info) 2709{ 2710 initGLES(); 2711 GLuint sampler = INT_INIT_VAL; 2712 glGenSamplers(CREAT_NUM_ONE, &sampler); 2713 glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_REPEAT); 2714 GLfloat param = INT_INIT_VAL; 2715 glGetSamplerParameterfv(sampler, GL_TEXTURE_WRAP_S, ¶m); 2716 GLenum glError = glGetError(); 2717 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 2718 destroyGLES(); 2719 return getError(env, glError); 2720} 2721static napi_value GLGetSamplerParameterIiv(napi_env env, napi_callback_info info) 2722{ 2723 initGLES(); 2724 GLuint sampler = INT_INIT_VAL; 2725 glGenSamplers(CREAT_NUM_ONE, &sampler); 2726 glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 2727 2728 GLint param = INT_INIT_VAL; 2729 glGetSamplerParameterIiv(sampler, GL_TEXTURE_MIN_FILTER, ¶m); 2730 GLenum glError = glGetError(); 2731 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 2732 destroyGLES(); 2733 return getError(env, glError); 2734} 2735static napi_value GLGetSamplerParameterIuiv(napi_env env, napi_callback_info info) 2736{ 2737 initGLES(); 2738 GLuint sampler = INT_INIT_VAL; 2739 glGenSamplers(CREAT_NUM_ONE, &sampler); 2740 glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 2741 GLuint param = INT_INIT_VAL; 2742 glGetSamplerParameterIuiv(sampler, GL_TEXTURE_MIN_FILTER, ¶m); 2743 GLenum glError = glGetError(); 2744 destroyGLES(); 2745 return getError(env, glError); 2746} 2747static napi_value GLGetSamplerParameteriv(napi_env env, napi_callback_info info) 2748{ 2749 initGLES(); 2750 GLuint sampler = INT_INIT_VAL; 2751 glGenSamplers(CREAT_NUM_ONE, &sampler); 2752 glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 2753 GLint param = INT_INIT_VAL; 2754 glGetSamplerParameteriv(sampler, GL_TEXTURE_MIN_FILTER, ¶m); 2755 GLenum glError = glGetError(); 2756 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 2757 destroyGLES(); 2758 return getError(env, glError); 2759} 2760 2761static napi_value GLGetShaderInfoLog(napi_env env, napi_callback_info info) 2762{ 2763 initGLES(); 2764 GLuint shaderFragment = esLoadShader(GL_FRAGMENT_SHADER, fragmentShaderSource); 2765 GLchar log[SUB_DATA_SIZE]; 2766 glGetShaderInfoLog(shaderFragment, SUB_DATA_SIZE, nullptr, log); 2767 GLenum glError = glGetError(); 2768 glDeleteShader(shaderFragment); 2769 destroyGLES(); 2770 return getError(env, glError); 2771} 2772 2773static napi_value GLGetShaderiv(napi_env env, napi_callback_info info) 2774{ 2775 initGLES(); 2776 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2777 GLint params; 2778 glGetShaderiv(shaderVertex, GL_COMPILE_STATUS, ¶ms); 2779 GLenum glError = glGetError(); 2780 glDeleteShader(shaderVertex); 2781 destroyGLES(); 2782 return getError(env, glError); 2783} 2784 2785static napi_value GLGetShaderPrecisionFormat(napi_env env, napi_callback_info info) 2786{ 2787 initGLES(); 2788 GLint range[2]; 2789 GLint precision; 2790 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_HIGH_FLOAT, range, &precision); 2791 GLenum glError = glGetError(); 2792 destroyGLES(); 2793 return getError(env, glError); 2794} 2795 2796static napi_value GLGetShaderSource(napi_env env, napi_callback_info info) 2797{ 2798 initGLES(); 2799 GLuint shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexShaderSource); 2800 GLsizei length; 2801 glGetShaderiv(shaderVertex, GL_SHADER_SOURCE_LENGTH, &length); 2802 GLenum glError = FAILED; 2803 if (length > 0) { 2804 GLchar source[length]; 2805 glGetShaderSource(shaderVertex, length, nullptr, source); 2806 glError = glGetError(); 2807 } 2808 glDeleteShader(shaderVertex); 2809 destroyGLES(); 2810 return getError(env, glError); 2811} 2812 2813static napi_value GLGetString(napi_env env, napi_callback_info info) 2814{ 2815 initGLES(); 2816 napi_value result = nullptr; 2817 const GLubyte *renderer = glGetString(GL_RENDERER); 2818 if (renderer != nullptr) { 2819 napi_create_int32(env, SUCCESS, &result); 2820 } else { 2821 napi_create_int32(env, FAILED, &result); 2822 } 2823 destroyGLES(); 2824 return result; 2825} 2826 2827static napi_value GLGetStringi(napi_env env, napi_callback_info info) 2828{ 2829 initGLES(); 2830 napi_value result = nullptr; 2831 const GLubyte *renderer = glGetStringi(GL_EXTENSIONS, INT_INIT_VAL); 2832 if (renderer != nullptr) { 2833 napi_create_int32(env, SUCCESS, &result); 2834 } else { 2835 napi_create_int32(env, FAILED, &result); 2836 } 2837 destroyGLES(); 2838 return result; 2839} 2840 2841static napi_value GLGetSynciv(napi_env env, napi_callback_info info) 2842{ 2843 initGLES(); 2844 GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, INT_INIT_VAL); 2845 GLsizei sizei = INT_INIT_VAL; 2846 GLint buff[256]; 2847 glGetSynciv(sync, GL_OBJECT_TYPE, sizei, nullptr, buff); 2848 GLenum glError = glGetError(); 2849 glDeleteSync(sync); 2850 destroyGLES(); 2851 return getError(env, glError); 2852} 2853 2854static napi_value GLGetTexLevelParameterfv(napi_env env, napi_callback_info info) 2855{ 2856 initGLES(); 2857 GLuint texture = INT_INIT_VAL; 2858 glGenTextures(CREAT_NUM_ONE, &texture); 2859 glBindTexture(GL_TEXTURE_2D, texture); 2860 GLfloat width; 2861 glGetTexLevelParameterfv(GL_TEXTURE_2D, INT_INIT_VAL, GL_TEXTURE_WIDTH, &width); 2862 GLenum glError = glGetError(); 2863 glDeleteTextures(CREAT_NUM_ONE, &texture); 2864 destroyGLES(); 2865 return getError(env, glError); 2866} 2867 2868static napi_value GLGetTexLevelParameteriv(napi_env env, napi_callback_info info) 2869{ 2870 initGLES(); 2871 GLuint texture = INT_INIT_VAL; 2872 glGenTextures(CREAT_NUM_ONE, &texture); 2873 glBindTexture(GL_TEXTURE_2D, texture); 2874 GLint width; 2875 glGetTexLevelParameteriv(GL_TEXTURE_2D, INT_INIT_VAL, GL_TEXTURE_WIDTH, &width); 2876 GLenum glError = glGetError(); 2877 glDeleteTextures(CREAT_NUM_ONE, &texture); 2878 destroyGLES(); 2879 return getError(env, glError); 2880} 2881 2882static napi_value GLGetTexParameterfv(napi_env env, napi_callback_info info) 2883{ 2884 initGLES(); 2885 GLuint texture = INT_INIT_VAL; 2886 glGenTextures(CREAT_NUM_ONE, &texture); 2887 glBindTexture(GL_TEXTURE_2D, texture); 2888 GLfloat params; 2889 glGetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, ¶ms); 2890 GLenum glError = glGetError(); 2891 glDeleteTextures(CREAT_NUM_ONE, &texture); 2892 destroyGLES(); 2893 return getError(env, glError); 2894} 2895 2896static napi_value GLGetTexParameterIiv(napi_env env, napi_callback_info info) 2897{ 2898 initGLES(); 2899 GLuint texture = INT_INIT_VAL; 2900 glGenTextures(CREAT_NUM_ONE, &texture); 2901 glBindTexture(GL_TEXTURE_2D, texture); 2902 GLint params; 2903 glGetTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, ¶ms); 2904 GLenum glError = glGetError(); 2905 glDeleteTextures(CREAT_NUM_ONE, &texture); 2906 destroyGLES(); 2907 return getError(env, glError); 2908} 2909 2910static napi_value GLGetTexParameterIuiv(napi_env env, napi_callback_info info) 2911{ 2912 initGLES(); 2913 GLuint texture = INT_INIT_VAL; 2914 glGenTextures(CREAT_NUM_ONE, &texture); 2915 glBindTexture(GL_TEXTURE_2D, texture); 2916 GLuint params; 2917 glGetTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, ¶ms); 2918 GLenum glError = glGetError(); 2919 glDeleteTextures(CREAT_NUM_ONE, &texture); 2920 destroyGLES(); 2921 return getError(env, glError); 2922} 2923 2924static napi_value GLGetTexParameteriv(napi_env env, napi_callback_info info) 2925{ 2926 initGLES(); 2927 GLuint texture = INT_INIT_VAL; 2928 glGenTextures(CREAT_NUM_ONE, &texture); 2929 glBindTexture(GL_TEXTURE_2D, texture); 2930 GLint params; 2931 glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, ¶ms); 2932 GLenum glError = glGetError(); 2933 glDeleteTextures(CREAT_NUM_ONE, &texture); 2934 destroyGLES(); 2935 return getError(env, glError); 2936} 2937 2938static napi_value GLGetTransformFeedbackVarying(napi_env env, napi_callback_info info) 2939{ 2940 initGLES(); 2941 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 2942 GLint index = glGetAttribLocation(program, "vPosition"); 2943 glBindAttribLocation(program, index, "vPosition"); 2944 const char *varyings = "gl_Position"; 2945 glTransformFeedbackVaryings(program, COUNT_NUM, &varyings, GL_INTERLEAVED_ATTRIBS); 2946 glLinkProgram(program); 2947 GLsizei size; 2948 GLenum type; 2949 GLchar name[SUB_DATA_SIZE]; 2950 glGetTransformFeedbackVarying(program, INT_INIT_VAL, SUB_DATA_SIZE, nullptr, &size, &type, name); 2951 GLenum glError = glGetError(); 2952 deleteProgram(); 2953 glDeleteProgram(program); 2954 destroyGLES(); 2955 return getError(env, glError); 2956} 2957 2958static napi_value GLGetUniformBlockIndex(napi_env env, napi_callback_info info) 2959{ 2960 initGLES(); 2961 GLuint program = initProgram(); 2962 GLuint blockIndex = glGetUniformBlockIndex(program, "MatrixBlock"); 2963 GLenum glError = glGetError(); 2964 if (blockIndex != GL_INVALID_INDEX) { 2965 glError = SUCCESS; 2966 } 2967 deleteProgram(); 2968 glDeleteProgram(program); 2969 destroyGLES(); 2970 return getError(env, glError); 2971} 2972 2973static napi_value GLGetUniformfv(napi_env env, napi_callback_info info) 2974{ 2975 initGLES(); 2976 GLuint program = initProgram(vertexSource, fragmentSource); 2977 GLint location = glGetUniformLocation(program, "color"); 2978 GLfloat param[4]; 2979 glGetUniformfv(program, location, param); 2980 GLenum glError = glGetError(); 2981 deleteProgram(); 2982 glDeleteProgram(program); 2983 destroyGLES(); 2984 return getError(env, glError); 2985} 2986 2987static napi_value GLGetUniformIndices(napi_env env, napi_callback_info info) 2988{ 2989 initGLES(); 2990 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 2991 GLuint Indices[2]; 2992 GLchar *names[] = {}; 2993 glGetUniformIndices(program, INT_INIT_VAL, names, Indices); 2994 GLenum glError = glGetError(); 2995 deleteProgram(); 2996 glDeleteProgram(program); 2997 destroyGLES(); 2998 return getError(env, glError); 2999} 3000 3001static napi_value GLGetUniformiv(napi_env env, napi_callback_info info) 3002{ 3003 initGLES(); 3004 GLuint program = initProgram(vertexSource, fragmentSource); 3005 GLint location = glGetUniformLocation(program, "color"); 3006 GLint param[4]; 3007 glGetUniformiv(program, location, param); 3008 GLenum glError = glGetError(); 3009 deleteProgram(); 3010 glDeleteProgram(program); 3011 destroyGLES(); 3012 return getError(env, glError); 3013} 3014 3015static napi_value GLGetUniformLocation(napi_env env, napi_callback_info info) 3016{ 3017 initGLES(); 3018 napi_value result = nullptr; 3019 GLuint program = initProgram(vertexSource, fragmentSource); 3020 GLint location = glGetUniformLocation(program, "color"); 3021 if (location != FAILED) { 3022 napi_create_int32(env, SUCCESS, &result); 3023 } else { 3024 napi_create_int32(env, FAILED, &result); 3025 } 3026 deleteProgram(); 3027 glDeleteProgram(program); 3028 destroyGLES(); 3029 return result; 3030} 3031 3032static napi_value GLGetUniformuiv(napi_env env, napi_callback_info info) 3033{ 3034 initGLES(); 3035 GLuint program = initProgram(vertexSource, fragmentSource); 3036 GLint location = glGetUniformLocation(program, "color"); 3037 GLuint param[4]; 3038 glGetUniformuiv(program, location, param); 3039 GLenum glError = glGetError(); 3040 deleteProgram(); 3041 glDeleteProgram(program); 3042 destroyGLES(); 3043 return getError(env, glError); 3044} 3045 3046static napi_value GLGetVertexAttribfv(napi_env env, napi_callback_info info) 3047{ 3048 initGLES(); 3049 GLenum glError = FAILED; 3050 shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexSource); 3051 GLint maxVertexAttribs; 3052 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs); 3053 GLfloat params[4]; 3054 if (maxVertexAttribs > INT_INIT_VAL) { 3055 glGetVertexAttribfv(ARRAY_INDEX_ZERO, GL_CURRENT_VERTEX_ATTRIB, params); 3056 glError = glGetError(); 3057 } 3058 glDeleteShader(shaderVertex); 3059 destroyGLES(); 3060 return getError(env, glError); 3061} 3062 3063static napi_value GLGetVertexAttribIiv(napi_env env, napi_callback_info info) 3064{ 3065 initGLES(); 3066 GLenum glError = FAILED; 3067 shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexSource); 3068 GLint maxVertexAttribs; 3069 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs); 3070 GLint params[4]; 3071 if (maxVertexAttribs > INT_INIT_VAL) { 3072 glGetVertexAttribIiv(ARRAY_INDEX_ZERO, GL_CURRENT_VERTEX_ATTRIB, params); 3073 glError = glGetError(); 3074 } 3075 glDeleteShader(shaderVertex); 3076 destroyGLES(); 3077 return getError(env, glError); 3078} 3079 3080static napi_value GLGetVertexAttribIuiv(napi_env env, napi_callback_info info) 3081{ 3082 initGLES(); 3083 GLenum glError = FAILED; 3084 shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexSource); 3085 GLint maxVertexAttribs; 3086 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs); 3087 GLuint params[4]; 3088 if (maxVertexAttribs > INT_INIT_VAL) { 3089 glGetVertexAttribIuiv(ARRAY_INDEX_ZERO, GL_CURRENT_VERTEX_ATTRIB, params); 3090 } 3091 glError = glGetError(); 3092 glDeleteShader(shaderVertex); 3093 destroyGLES(); 3094 return getError(env, glError); 3095} 3096 3097static napi_value GLGetVertexAttribiv(napi_env env, napi_callback_info info) 3098{ 3099 initGLES(); 3100 GLenum glError = FAILED; 3101 shaderVertex = esLoadShader(GL_VERTEX_SHADER, vertexSource); 3102 GLint maxVertexAttribs; 3103 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs); 3104 GLint params[4]; 3105 if (maxVertexAttribs > INT_INIT_VAL) { 3106 glGetVertexAttribiv(ARRAY_INDEX_ZERO, GL_CURRENT_VERTEX_ATTRIB, params); 3107 } 3108 glError = glGetError(); 3109 glDeleteShader(shaderVertex); 3110 destroyGLES(); 3111 return getError(env, glError); 3112} 3113 3114static napi_value GLGetVertexAttribPointerv(napi_env env, napi_callback_info info) 3115{ 3116 initGLES(); 3117 GLvoid *attribPointer; 3118 glGetVertexAttribPointerv(INT_INIT_VAL, GL_VERTEX_ATTRIB_ARRAY_POINTER, &attribPointer); 3119 GLenum glError = glGetError(); 3120 destroyGLES(); 3121 return getError(env, glError); 3122} 3123 3124static napi_value GLHint(napi_env env, napi_callback_info info) 3125{ 3126 initGLES(); 3127 glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT, GL_FASTEST); 3128 GLenum glError = glGetError(); 3129 destroyGLES(); 3130 return getError(env, glError); 3131} 3132 3133static napi_value GLInvalidateFramebuffer(napi_env env, napi_callback_info info) 3134{ 3135 initGLES(); 3136 GLuint fbo, tex, rbo; 3137 glGenTextures(CREAT_NUM_ONE, &tex); 3138 glBindTexture(GL_TEXTURE_2D, tex); 3139 glTexStorage2D(GL_TEXTURE_2D, CREAT_NUM_ONE, GL_RGBA8, INIT_WIDTH, INIT_HEIGHT); 3140 glGenRenderbuffers(CREAT_NUM_ONE, &rbo); 3141 glBindRenderbuffer(GL_RENDERBUFFER, rbo); 3142 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, INIT_WIDTH, INIT_HEIGHT); 3143 3144 glGenFramebuffers(CREAT_NUM_ONE, &fbo); 3145 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 3146 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, INT_INIT_VAL); 3147 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo); 3148 GLenum attachments[2] = {GL_DEPTH_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0}; 3149 glInvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments); 3150 GLenum glError = glGetError(); 3151 3152 glDeleteFramebuffers(CREAT_NUM_ONE, &fbo); 3153 glDeleteRenderbuffers(CREAT_NUM_ONE, &rbo); 3154 glDeleteTextures(CREAT_NUM_ONE, &tex); 3155 destroyGLES(); 3156 return getError(env, glError); 3157} 3158 3159static napi_value GLInvalidateSubFramebuffer(napi_env env, napi_callback_info info) 3160{ 3161 initGLES(); 3162 GLuint fbo, tex; 3163 glGenFramebuffers(CREAT_NUM_ONE, &fbo); 3164 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 3165 glGenTextures(CREAT_NUM_ONE, &tex); 3166 glBindTexture(GL_TEXTURE_2D, tex); 3167 glTexStorage2D(GL_TEXTURE_2D, IMAGE2D_LEVEL_ONE, GL_RGBA8, INIT_WIDTH, INIT_HEIGHT); 3168 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, INT_INIT_VAL); 3169 GLenum attachments[1] = {GL_COLOR_ATTACHMENT0}; 3170 glInvalidateSubFramebuffer(GL_FRAMEBUFFER, COUNT_NUM, attachments, 100, 100, 300, 300); 3171 GLenum glError = glGetError(); 3172 3173 glDeleteFramebuffers(CREAT_NUM_ONE, &fbo); 3174 glDeleteTextures(CREAT_NUM_ONE, &tex); 3175 destroyGLES(); 3176 return getError(env, glError); 3177} 3178 3179static napi_value GLIsBuffer(napi_env env, napi_callback_info info) 3180{ 3181 initGLES(); 3182 napi_value result = nullptr; 3183 GLuint buffer = INT_INIT_VAL; 3184 glGenBuffers(CREAT_NUM_ONE, &buffer); 3185 glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer); 3186 GLboolean isBuffer = glIsBuffer(buffer); 3187 if (isBuffer) { 3188 napi_create_int32(env, SUCCESS, &result); 3189 } else { 3190 napi_create_int32(env, FAILED, &result); 3191 } 3192 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 3193 destroyGLES(); 3194 return result; 3195} 3196 3197static napi_value GLIsEnabled(napi_env env, napi_callback_info info) 3198{ 3199 initGLES(); 3200 napi_value result = nullptr; 3201 GLboolean isEnabled = glIsEnabled(GL_DITHER); 3202 if (isEnabled) { 3203 napi_create_int32(env, SUCCESS, &result); 3204 } else { 3205 napi_create_int32(env, FAILED, &result); 3206 } 3207 destroyGLES(); 3208 return result; 3209} 3210 3211static napi_value GLIsEnabledi(napi_env env, napi_callback_info info) 3212{ 3213 initGLES(); 3214 napi_value result = nullptr; 3215 glEnablei(GL_BLEND, INT_INIT_VAL); 3216 GLboolean isEnabled = glIsEnabledi(GL_BLEND, INT_INIT_VAL); 3217 if (isEnabled) { 3218 napi_create_int32(env, SUCCESS, &result); 3219 } else { 3220 napi_create_int32(env, FAILED, &result); 3221 } 3222 destroyGLES(); 3223 return result; 3224} 3225 3226static napi_value GLIsFramebuffer(napi_env env, napi_callback_info info) 3227{ 3228 initGLES(); 3229 napi_value result = nullptr; 3230 GLuint framebuffer = INT_INIT_VAL; 3231 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 3232 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 3233 GLboolean isFramebuffer = glIsFramebuffer(framebuffer); 3234 if (isFramebuffer) { 3235 napi_create_int32(env, SUCCESS, &result); 3236 } else { 3237 napi_create_int32(env, FAILED, &result); 3238 } 3239 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 3240 destroyGLES(); 3241 return result; 3242} 3243 3244static napi_value GLIsProgram(napi_env env, napi_callback_info info) 3245{ 3246 initGLES(); 3247 napi_value result = nullptr; 3248 GLuint Program = glCreateProgram(); 3249 GLboolean isProgram = glIsProgram(Program); 3250 if (isProgram) { 3251 napi_create_int32(env, SUCCESS, &result); 3252 } else { 3253 napi_create_int32(env, FAILED, &result); 3254 } 3255 glDeleteProgram(Program); 3256 destroyGLES(); 3257 return result; 3258} 3259 3260static napi_value GLIsProgramPipeline(napi_env env, napi_callback_info info) 3261{ 3262 initGLES(); 3263 napi_value result = nullptr; 3264 GLuint pipeline = INT_INIT_VAL; 3265 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 3266 glBindProgramPipeline(pipeline); 3267 GLboolean isPipeline = glIsProgramPipeline(pipeline); 3268 if (isPipeline) { 3269 napi_create_int32(env, SUCCESS, &result); 3270 } else { 3271 napi_create_int32(env, FAILED, &result); 3272 } 3273 glDeleteProgramPipelines(CREAT_NUM_ONE, &pipeline); 3274 destroyGLES(); 3275 return result; 3276} 3277 3278static napi_value GLIsQuery(napi_env env, napi_callback_info info) 3279{ 3280 initGLES(); 3281 napi_value result = nullptr; 3282 GLuint query = INT_INIT_VAL; 3283 glGenQueries(CREAT_NUM_ONE, &query); 3284 glBeginQuery(GL_ANY_SAMPLES_PASSED, query); 3285 GLboolean isQuery = glIsQuery(query); 3286 if (isQuery) { 3287 napi_create_int32(env, SUCCESS, &result); 3288 } else { 3289 napi_create_int32(env, FAILED, &result); 3290 } 3291 glDeleteQueries(CREAT_NUM_ONE, &query); 3292 destroyGLES(); 3293 return result; 3294} 3295 3296static napi_value GLIsRenderbuffer(napi_env env, napi_callback_info info) 3297{ 3298 initGLES(); 3299 napi_value result = nullptr; 3300 GLuint renderBuffer = INT_INIT_VAL; 3301 glGenRenderbuffers(CREAT_NUM_ONE, &renderBuffer); 3302 glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer); 3303 GLboolean isRenderbuffer = glIsRenderbuffer(renderBuffer); 3304 if (isRenderbuffer) { 3305 napi_create_int32(env, SUCCESS, &result); 3306 } else { 3307 napi_create_int32(env, FAILED, &result); 3308 } 3309 glDeleteRenderbuffers(CREAT_NUM_ONE, &renderBuffer); 3310 destroyGLES(); 3311 return result; 3312} 3313 3314static napi_value GLIsSampler(napi_env env, napi_callback_info info) 3315{ 3316 initGLES(); 3317 napi_value result = nullptr; 3318 GLuint sampler = INT_INIT_VAL; 3319 glGenSamplers(CREAT_NUM_ONE, &sampler); 3320 GLboolean isSampler = glIsSampler(sampler); 3321 if (isSampler) { 3322 napi_create_int32(env, SUCCESS, &result); 3323 } else { 3324 napi_create_int32(env, FAILED, &result); 3325 } 3326 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 3327 destroyGLES(); 3328 return result; 3329} 3330 3331static napi_value GLIsShader(napi_env env, napi_callback_info info) 3332{ 3333 initGLES(); 3334 napi_value result = nullptr; 3335 GLuint shader = glCreateShader(GL_VERTEX_SHADER); 3336 GLboolean isShader = glIsShader(shader); 3337 if (isShader) { 3338 napi_create_int32(env, SUCCESS, &result); 3339 } else { 3340 napi_create_int32(env, FAILED, &result); 3341 } 3342 glDeleteSamplers(CREAT_NUM_ONE, &shader); 3343 destroyGLES(); 3344 return result; 3345} 3346 3347static napi_value GLIsSync(napi_env env, napi_callback_info info) 3348{ 3349 initGLES(); 3350 napi_value result = nullptr; 3351 GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, INT_INIT_VAL); 3352 GLboolean isSync = glIsSync(sync); 3353 if (isSync) { 3354 napi_create_int32(env, SUCCESS, &result); 3355 } else { 3356 napi_create_int32(env, FAILED, &result); 3357 } 3358 glDeleteSync(sync); 3359 destroyGLES(); 3360 return result; 3361} 3362 3363static napi_value GLIsTexture(napi_env env, napi_callback_info info) 3364{ 3365 initGLES(); 3366 napi_value result = nullptr; 3367 GLuint texture = INT_INIT_VAL; 3368 glGenTextures(CREAT_NUM_ONE, &texture); 3369 glBindTexture(GL_TEXTURE_2D, texture); 3370 GLboolean isTexture = glIsTexture(texture); 3371 if (isTexture) { 3372 napi_create_int32(env, SUCCESS, &result); 3373 } else { 3374 napi_create_int32(env, FAILED, &result); 3375 } 3376 glDeleteTextures(CREAT_NUM_ONE, &texture); 3377 destroyGLES(); 3378 return result; 3379} 3380 3381static napi_value GLIsTransformFeedback(napi_env env, napi_callback_info info) 3382{ 3383 initGLES(); 3384 napi_value result = nullptr; 3385 GLuint id = INT_INIT_VAL; 3386 glGenTransformFeedbacks(CREAT_NUM_ONE, &id); 3387 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, id); 3388 GLboolean isId = glIsTransformFeedback(id); 3389 if (isId) { 3390 napi_create_int32(env, SUCCESS, &result); 3391 } else { 3392 napi_create_int32(env, FAILED, &result); 3393 } 3394 glDeleteTransformFeedbacks(CREAT_NUM_ONE, &id); 3395 destroyGLES(); 3396 return result; 3397} 3398 3399static napi_value GLIsVertexArray(napi_env env, napi_callback_info info) 3400{ 3401 initGLES(); 3402 napi_value result = nullptr; 3403 GLuint array = INT_INIT_VAL; 3404 glGenVertexArrays(CREAT_NUM_ONE, &array); 3405 glBindVertexArray(array); 3406 GLboolean isArray = glIsVertexArray(array); 3407 if (isArray) { 3408 napi_create_int32(env, SUCCESS, &result); 3409 } else { 3410 napi_create_int32(env, FAILED, &result); 3411 } 3412 glDeleteVertexArrays(CREAT_NUM_ONE, &array); 3413 destroyGLES(); 3414 return result; 3415} 3416 3417static napi_value GLLineWidth(napi_env env, napi_callback_info info) 3418{ 3419 initGLES(); 3420 glLineWidth(CLEAR_50); 3421 GLenum glError = glGetError(); 3422 destroyGLES(); 3423 return getError(env, glError); 3424} 3425 3426static napi_value GLLinkProgram(napi_env env, napi_callback_info info) 3427{ 3428 initGLES(); 3429 GLuint program = glCreateProgram(); 3430 glLinkProgram(program); 3431 GLenum glError = glGetError(); 3432 glDeleteProgram(program); 3433 destroyGLES(); 3434 return getError(env, glError); 3435} 3436 3437static napi_value GLMapBufferRange(napi_env env, napi_callback_info info) 3438{ 3439 initGLES(); 3440 napi_value result = nullptr; 3441 GLuint buffer = INT_INIT_VAL; 3442 glGenBuffers(CREAT_NUM_ONE, &buffer); 3443 glBindBuffer(GL_ARRAY_BUFFER, buffer); 3444 glBufferData(GL_ARRAY_BUFFER, GL_BUF_SIZE, nullptr, GL_DYNAMIC_DRAW); 3445 GLvoid *ptr = glMapBufferRange(GL_ARRAY_BUFFER, INT_INIT_VAL, GL_BUF_SIZE, GL_MAP_WRITE_BIT); 3446 if (ptr) { 3447 napi_create_int32(env, SUCCESS, &result); 3448 } else { 3449 napi_create_int32(env, FAILED, &result); 3450 } 3451 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 3452 destroyGLES(); 3453 return result; 3454} 3455 3456static napi_value GLMemoryBarrier(napi_env env, napi_callback_info info) 3457{ 3458 initGLES(); 3459 glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT); 3460 GLenum glError = glGetError(); 3461 destroyGLES(); 3462 return getError(env, glError); 3463} 3464 3465static napi_value GLMemoryBarrierByRegion(napi_env env, napi_callback_info info) 3466{ 3467 initGLES(); 3468 GLuint framebuffer = INT_INIT_VAL; 3469 GLuint texture = INT_INIT_VAL; 3470 glGenFramebuffers(CREAT_NUM_ONE, &framebuffer); 3471 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); 3472 glGenTextures(CREAT_NUM_ONE, &texture); 3473 glBindTexture(GL_TEXTURE_2D, texture); 3474 glTexStorage2D(GL_TEXTURE_2D, IMAGE2D_LEVEL_ONE, GL_RGBA8, INIT_WIDTH, INIT_HEIGHT); 3475 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, INT_INIT_VAL); 3476 glMemoryBarrierByRegion(GL_FRAMEBUFFER_BARRIER_BIT); 3477 GLenum glError = glGetError(); 3478 glDeleteFramebuffers(CREAT_NUM_ONE, &framebuffer); 3479 glDeleteTextures(CREAT_NUM_ONE, &texture); 3480 destroyGLES(); 3481 return getError(env, glError); 3482} 3483 3484static napi_value GLMinSampleShading(napi_env env, napi_callback_info info) 3485{ 3486 initGLES(); 3487 glMinSampleShading(INT_INIT_VAL); 3488 GLenum glError = glGetError(); 3489 destroyGLES(); 3490 return getError(env, glError); 3491} 3492 3493static napi_value GLObjectLabel(napi_env env, napi_callback_info info) 3494{ 3495 initGLES(); 3496 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 3497 char log[] = "My program log"; 3498 glObjectLabel(GL_PROGRAM, program, sizeof(log), log); 3499 GLenum glError = glGetError(); 3500 deleteProgram(); 3501 glDeleteProgram(program); 3502 destroyGLES(); 3503 return getError(env, glError); 3504} 3505 3506static napi_value GLObjectPtrLabel(napi_env env, napi_callback_info info) 3507{ 3508 initGLES(); 3509 GLsync syncObject = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, INT_INIT_VAL); 3510 char log[] = "My program log"; 3511 glObjectPtrLabel(syncObject, sizeof(log), log); 3512 GLenum glError = glGetError(); 3513 glDeleteSync(syncObject); 3514 destroyGLES(); 3515 return getError(env, glError); 3516} 3517 3518static napi_value GLPatchParameteri(napi_env env, napi_callback_info info) 3519{ 3520 initGLES(); 3521 GLuint array; 3522 glGenVertexArrays(CREAT_NUM_ONE, &array); 3523 glBindVertexArray(array); 3524 glPatchParameteri(GL_PATCH_VERTICES, ARRAY_INDEX_THREE); 3525 GLenum glError = glGetError(); 3526 glDeleteVertexArrays(CREAT_NUM_ONE, &array); 3527 destroyGLES(); 3528 return getError(env, glError); 3529} 3530 3531static napi_value GLPauseTransformFeedback(napi_env env, napi_callback_info info) 3532{ 3533 initGLES(); 3534 GLuint array; 3535 GLuint buffer; 3536 GLuint feedbackBuffer; 3537 GLuint tbBuffer; 3538 glGenBuffers(CREAT_NUM_ONE, &tbBuffer); 3539 glGenBuffers(CREAT_NUM_ONE, &feedbackBuffer); 3540 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 3541 glUseProgram(program); 3542 GLuint transformFeedback; 3543 glGenTransformFeedbacks(CREAT_NUM_ONE, &transformFeedback); 3544 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback); 3545 glGenVertexArrays(CREAT_NUM_ONE, &array); 3546 glGenBuffers(CREAT_NUM_ONE, &buffer); 3547 glBindVertexArray(array); 3548 glBindBuffer(GL_ARRAY_BUFFER, buffer); 3549 3550 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, INT_INIT_VAL, feedbackBuffer); 3551 glEnable(GL_RASTERIZER_DISCARD); 3552 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, INT_INIT_VAL, tbBuffer); 3553 glTransformFeedbackVaryings(program, VARYING_NUM, (const char*[]){"gl_Position", "vColor"}, GL_SEPARATE_ATTRIBS); 3554 glLinkProgram(program); 3555 3556 glBeginTransformFeedback(GL_POINTS); 3557 glPauseTransformFeedback(); 3558 GLenum glError = glGetError(); 3559 3560 deleteProgram(); 3561 glDeleteProgram(program); 3562 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 3563 glDeleteBuffers(CREAT_NUM_ONE, &feedbackBuffer); 3564 glDeleteVertexArrays(CREAT_NUM_ONE, &array); 3565 destroyGLES(); 3566 return getError(env, glError); 3567} 3568 3569static napi_value GLPixelStorei(napi_env env, napi_callback_info info) 3570{ 3571 initGLES(); 3572 GLuint texture = INT_INIT_VAL; 3573 glGenTextures(CREAT_NUM_ONE, &texture); 3574 glBindTexture(GL_TEXTURE_2D, texture); 3575 glPixelStorei(GL_UNPACK_ALIGNMENT, CREAT_NUM_ONE); 3576 GLenum glError = glGetError(); 3577 glDeleteTextures(CREAT_NUM_ONE, &texture); 3578 destroyGLES(); 3579 return getError(env, glError); 3580} 3581 3582static napi_value GLPolygonOffset(napi_env env, napi_callback_info info) 3583{ 3584 initGLES(); 3585 glEnable(GL_DEPTH_TEST); 3586 glPolygonOffset(CLEAR_10, CLEAR_10); 3587 GLenum glError = glGetError(); 3588 destroyGLES(); 3589 return getError(env, glError); 3590} 3591 3592static napi_value GLPopDebugGroup(napi_env env, napi_callback_info info) 3593{ 3594 initGLES(); 3595 glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, INT_INIT_VAL, FAILED, "Draw Scene"); 3596 glPopDebugGroup(); 3597 GLenum glError = glGetError(); 3598 destroyGLES(); 3599 return getError(env, glError); 3600} 3601 3602static napi_value GLPrimitiveBoundingBox(napi_env env, napi_callback_info info) 3603{ 3604 initGLES(); 3605 glPrimitiveBoundingBox(CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10); 3606 GLenum glError = glGetError(); 3607 destroyGLES(); 3608 return getError(env, glError); 3609} 3610 3611static napi_value GLProgramBinary(napi_env env, napi_callback_info info) 3612{ 3613 initGLES(); 3614 GLuint program = initProgram(); 3615 GLuint programBin = glCreateProgram(); 3616 GLint binaryLength = INT_INIT_VAL; 3617 glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength); 3618 GLubyte *binary = (GLubyte *)malloc(binaryLength); 3619 GLenum binaryFormat = INT_INIT_VAL; 3620 GLsizei length = INT_INIT_VAL; 3621 glGetProgramBinary(program, binaryLength, &length, &binaryFormat, binary); 3622 glProgramBinary(programBin, binaryFormat, binary, length); 3623 GLenum glError = glGetError(); 3624 free(binary); 3625 deleteProgram(); 3626 glDeleteProgram(program); 3627 glDeleteProgram(programBin); 3628 destroyGLES(); 3629 return getError(env, glError); 3630} 3631 3632static napi_value GLProgramParameteri(napi_env env, napi_callback_info info) 3633{ 3634 initGLES(); 3635 GLuint program = glCreateProgram(); 3636 glProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE); 3637 GLenum glError = glGetError(); 3638 glDeleteProgram(program); 3639 destroyGLES(); 3640 return getError(env, glError); 3641} 3642 3643static napi_value GLProgramUniform1f(napi_env env, napi_callback_info info) 3644{ 3645 initGLES(); 3646 GLuint programObject = initProgram(); 3647 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3648 glProgramUniform1f(programObject, uniformLocation, CLEAR_10); 3649 GLenum glError = glGetError(); 3650 deleteProgram(); 3651 glDeleteProgram(programObject); 3652 destroyGLES(); 3653 return getError(env, glError); 3654} 3655 3656static napi_value GLProgramUniform1fv(napi_env env, napi_callback_info info) 3657{ 3658 initGLES(); 3659 GLuint programObject = initProgram(); 3660 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3661 GLfloat brightness[POINT_LIGHT_COUNT] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 3662 glProgramUniform1fv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3663 GLenum glError = glGetError(); 3664 deleteProgram(); 3665 glDeleteProgram(programObject); 3666 destroyGLES(); 3667 return getError(env, glError); 3668} 3669 3670static napi_value GLProgramUniform1i(napi_env env, napi_callback_info info) 3671{ 3672 initGLES(); 3673 GLuint programObject = initProgram(); 3674 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3675 glProgramUniform1i(programObject, uniformLocation, COUNT_NUM); 3676 GLenum glError = glGetError(); 3677 deleteProgram(); 3678 glDeleteProgram(programObject); 3679 destroyGLES(); 3680 return getError(env, glError); 3681} 3682 3683static napi_value GLProgramUniform1iv(napi_env env, napi_callback_info info) 3684{ 3685 initGLES(); 3686 GLuint programObject = initProgram(); 3687 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3688 GLint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3689 glProgramUniform1iv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3690 GLenum glError = glGetError(); 3691 deleteProgram(); 3692 glDeleteProgram(programObject); 3693 destroyGLES(); 3694 return getError(env, glError); 3695} 3696 3697static napi_value GLProgramUniform1ui(napi_env env, napi_callback_info info) 3698{ 3699 initGLES(); 3700 GLuint programObject = initProgram(); 3701 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3702 glProgramUniform1ui(programObject, uniformLocation, COUNT_NUM); 3703 GLenum glError = glGetError(); 3704 deleteProgram(); 3705 glDeleteProgram(programObject); 3706 destroyGLES(); 3707 return getError(env, glError); 3708} 3709 3710static napi_value GLProgramUniform1uiv(napi_env env, napi_callback_info info) 3711{ 3712 initGLES(); 3713 GLuint programObject = initProgram(); 3714 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3715 GLuint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3716 glProgramUniform1uiv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3717 GLenum glError = glGetError(); 3718 deleteProgram(); 3719 glDeleteProgram(programObject); 3720 destroyGLES(); 3721 return getError(env, glError); 3722} 3723 3724static napi_value GLProgramUniform2f(napi_env env, napi_callback_info info) 3725{ 3726 initGLES(); 3727 GLuint programObject = initProgram(); 3728 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3729 glProgramUniform2f(programObject, uniformLocation, CLEAR_10, CLEAR_10); 3730 GLenum glError = glGetError(); 3731 deleteProgram(); 3732 glDeleteProgram(programObject); 3733 destroyGLES(); 3734 return getError(env, glError); 3735} 3736 3737static napi_value GLProgramUniform2fv(napi_env env, napi_callback_info info) 3738{ 3739 initGLES(); 3740 GLuint programObject = initProgram(); 3741 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3742 GLfloat brightness[POINT_LIGHT_COUNT] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 3743 glProgramUniform2fv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3744 GLenum glError = glGetError(); 3745 deleteProgram(); 3746 glDeleteProgram(programObject); 3747 destroyGLES(); 3748 return getError(env, glError); 3749} 3750 3751static napi_value GLProgramUniform2i(napi_env env, napi_callback_info info) 3752{ 3753 initGLES(); 3754 GLuint programObject = initProgram(); 3755 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3756 glProgramUniform2i(programObject, uniformLocation, COUNT_NUM, COUNT_NUM); 3757 GLenum glError = glGetError(); 3758 deleteProgram(); 3759 glDeleteProgram(programObject); 3760 destroyGLES(); 3761 return getError(env, glError); 3762} 3763 3764static napi_value GLProgramUniform2iv(napi_env env, napi_callback_info info) 3765{ 3766 initGLES(); 3767 GLuint programObject = initProgram(); 3768 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3769 GLint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3770 glProgramUniform2iv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3771 GLenum glError = glGetError(); 3772 deleteProgram(); 3773 glDeleteProgram(programObject); 3774 destroyGLES(); 3775 return getError(env, glError); 3776} 3777 3778static napi_value GLProgramUniform2ui(napi_env env, napi_callback_info info) 3779{ 3780 initGLES(); 3781 GLuint programObject = initProgram(); 3782 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3783 glProgramUniform2ui(programObject, uniformLocation, COUNT_NUM, COUNT_NUM); 3784 GLenum glError = glGetError(); 3785 deleteProgram(); 3786 glDeleteProgram(programObject); 3787 destroyGLES(); 3788 return getError(env, glError); 3789} 3790 3791static napi_value GLProgramUniform2uiv(napi_env env, napi_callback_info info) 3792{ 3793 initGLES(); 3794 GLuint programObject = initProgram(); 3795 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3796 GLuint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3797 glProgramUniform2uiv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3798 GLenum glError = glGetError(); 3799 deleteProgram(); 3800 glDeleteProgram(programObject); 3801 destroyGLES(); 3802 return getError(env, glError); 3803} 3804 3805static napi_value GLProgramUniform3f(napi_env env, napi_callback_info info) 3806{ 3807 initGLES(); 3808 GLuint programObject = initProgram(); 3809 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3810 glProgramUniform3f(programObject, uniformLocation, CLEAR_10, CLEAR_10, CLEAR_10); 3811 GLenum glError = glGetError(); 3812 deleteProgram(); 3813 glDeleteProgram(programObject); 3814 destroyGLES(); 3815 return getError(env, glError); 3816} 3817 3818static napi_value GLProgramUniform3fv(napi_env env, napi_callback_info info) 3819{ 3820 initGLES(); 3821 GLuint programObject = initProgram(); 3822 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3823 GLfloat brightness[POINT_LIGHT_COUNT] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 3824 glProgramUniform3fv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3825 GLenum glError = glGetError(); 3826 deleteProgram(); 3827 glDeleteProgram(programObject); 3828 destroyGLES(); 3829 return getError(env, glError); 3830} 3831 3832static napi_value GLProgramUniform3i(napi_env env, napi_callback_info info) 3833{ 3834 initGLES(); 3835 GLuint programObject = initProgram(); 3836 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3837 glProgramUniform3i(programObject, uniformLocation, COUNT_NUM, COUNT_NUM, COUNT_NUM); 3838 GLenum glError = glGetError(); 3839 deleteProgram(); 3840 glDeleteProgram(programObject); 3841 destroyGLES(); 3842 return getError(env, glError); 3843} 3844 3845static napi_value GLProgramUniform3iv(napi_env env, napi_callback_info info) 3846{ 3847 initGLES(); 3848 GLuint programObject = initProgram(); 3849 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3850 GLint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3851 glProgramUniform3iv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3852 GLenum glError = glGetError(); 3853 deleteProgram(); 3854 glDeleteProgram(programObject); 3855 destroyGLES(); 3856 return getError(env, glError); 3857} 3858 3859static napi_value GLProgramUniform3ui(napi_env env, napi_callback_info info) 3860{ 3861 initGLES(); 3862 GLuint programObject = initProgram(); 3863 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3864 glProgramUniform3ui(programObject, uniformLocation, COUNT_NUM, COUNT_NUM, COUNT_NUM); 3865 GLenum glError = glGetError(); 3866 deleteProgram(); 3867 glDeleteProgram(programObject); 3868 destroyGLES(); 3869 return getError(env, glError); 3870} 3871 3872static napi_value GLProgramUniform3uiv(napi_env env, napi_callback_info info) 3873{ 3874 initGLES(); 3875 GLuint programObject = initProgram(); 3876 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3877 GLuint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3878 glProgramUniform3uiv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3879 GLenum glError = glGetError(); 3880 deleteProgram(); 3881 glDeleteProgram(programObject); 3882 destroyGLES(); 3883 return getError(env, glError); 3884} 3885 3886static napi_value GLProgramUniform4f(napi_env env, napi_callback_info info) 3887{ 3888 initGLES(); 3889 GLuint programObject = initProgram(); 3890 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3891 glProgramUniform4f(programObject, uniformLocation, CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10); 3892 GLenum glError = glGetError(); 3893 deleteProgram(); 3894 glDeleteProgram(programObject); 3895 destroyGLES(); 3896 return getError(env, glError); 3897} 3898 3899static napi_value GLProgramUniform4fv(napi_env env, napi_callback_info info) 3900{ 3901 initGLES(); 3902 GLuint programObject = initProgram(); 3903 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3904 GLfloat brightness[POINT_LIGHT_COUNT] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 3905 glProgramUniform4fv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3906 GLenum glError = glGetError(); 3907 deleteProgram(); 3908 glDeleteProgram(programObject); 3909 destroyGLES(); 3910 return getError(env, glError); 3911} 3912 3913static napi_value GLProgramUniform4i(napi_env env, napi_callback_info info) 3914{ 3915 initGLES(); 3916 GLuint programObject = initProgram(); 3917 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3918 glProgramUniform4i(programObject, uniformLocation, COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM); 3919 GLenum glError = glGetError(); 3920 deleteProgram(); 3921 glDeleteProgram(programObject); 3922 destroyGLES(); 3923 return getError(env, glError); 3924} 3925 3926static napi_value GLProgramUniform4iv(napi_env env, napi_callback_info info) 3927{ 3928 initGLES(); 3929 GLuint programObject = initProgram(); 3930 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3931 GLint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3932 glProgramUniform4iv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3933 GLenum glError = glGetError(); 3934 deleteProgram(); 3935 glDeleteProgram(programObject); 3936 destroyGLES(); 3937 return getError(env, glError); 3938} 3939 3940static napi_value GLProgramUniform4ui(napi_env env, napi_callback_info info) 3941{ 3942 initGLES(); 3943 GLuint programObject = initProgram(); 3944 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3945 glProgramUniform4ui(programObject, uniformLocation, COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM); 3946 GLenum glError = glGetError(); 3947 deleteProgram(); 3948 glDeleteProgram(programObject); 3949 destroyGLES(); 3950 return getError(env, glError); 3951} 3952 3953static napi_value GLProgramUniform4uiv(napi_env env, napi_callback_info info) 3954{ 3955 initGLES(); 3956 GLuint programObject = initProgram(); 3957 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3958 GLuint brightness[POINT_LIGHT_COUNT] = {COUNT_NUM, COUNT_NUM, COUNT_NUM, COUNT_NUM}; 3959 glProgramUniform4uiv(programObject, uniformLocation, POINT_LIGHT_COUNT, brightness); 3960 GLenum glError = glGetError(); 3961 deleteProgram(); 3962 glDeleteProgram(programObject); 3963 destroyGLES(); 3964 return getError(env, glError); 3965} 3966 3967static napi_value GLProgramUniformMatrix2fv(napi_env env, napi_callback_info info) 3968{ 3969 initGLES(); 3970 GLuint programObject = initProgram(); 3971 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3972 GLfloat matrix[MATRIX_4] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10}; 3973 glProgramUniformMatrix2fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 3974 GLenum glError = glGetError(); 3975 deleteProgram(); 3976 glDeleteProgram(programObject); 3977 destroyGLES(); 3978 return getError(env, glError); 3979} 3980 3981static napi_value GLProgramUniformMatrix2x3fv(napi_env env, napi_callback_info info) 3982{ 3983 initGLES(); 3984 GLuint programObject = initProgram(); 3985 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 3986 GLfloat matrix[MATRIX_6] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10}; 3987 glProgramUniformMatrix2x3fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 3988 GLenum glError = glGetError(); 3989 deleteProgram(); 3990 glDeleteProgram(programObject); 3991 destroyGLES(); 3992 return getError(env, glError); 3993} 3994 3995static napi_value GLProgramUniformMatrix2x4fv(napi_env env, napi_callback_info info) 3996{ 3997 initGLES(); 3998 GLuint programObject = initProgram(); 3999 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4000 GLfloat matrix[MATRIX_8] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10}; 4001 glProgramUniformMatrix2x4fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 4002 GLenum glError = glGetError(); 4003 deleteProgram(); 4004 glDeleteProgram(programObject); 4005 destroyGLES(); 4006 return getError(env, glError); 4007} 4008 4009static napi_value GLProgramUniformMatrix3fv(napi_env env, napi_callback_info info) 4010{ 4011 initGLES(); 4012 GLuint programObject = initProgram(); 4013 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4014 GLfloat matrix[MATRIX_9] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, 4015 CLEAR_10, CLEAR_00, CLEAR_10, CLEAR_10}; 4016 glProgramUniformMatrix3fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 4017 GLenum glError = glGetError(); 4018 deleteProgram(); 4019 glDeleteProgram(programObject); 4020 destroyGLES(); 4021 return getError(env, glError); 4022} 4023 4024static napi_value GLProgramUniformMatrix3x2fv(napi_env env, napi_callback_info info) 4025{ 4026 initGLES(); 4027 GLuint programObject = initProgram(); 4028 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4029 GLfloat matrix[MATRIX_6] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10}; 4030 glProgramUniformMatrix3x2fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 4031 GLenum glError = glGetError(); 4032 deleteProgram(); 4033 glDeleteProgram(programObject); 4034 destroyGLES(); 4035 return getError(env, glError); 4036} 4037 4038static napi_value GLProgramUniformMatrix3x4fv(napi_env env, napi_callback_info info) 4039{ 4040 initGLES(); 4041 GLuint programObject = initProgram(); 4042 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4043 GLfloat matrix[MATRIX_12] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, 4044 CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00}; 4045 glProgramUniformMatrix3x4fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 4046 GLenum glError = glGetError(); 4047 deleteProgram(); 4048 glDeleteProgram(programObject); 4049 destroyGLES(); 4050 return getError(env, glError); 4051} 4052 4053static napi_value GLProgramUniformMatrix4fv(napi_env env, napi_callback_info info) 4054{ 4055 initGLES(); 4056 GLuint programObject = initProgram(); 4057 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4058 GLfloat matrix[MATRIX_16] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_00, 4059 CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10}; 4060 glProgramUniformMatrix4fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 4061 GLenum glError = glGetError(); 4062 deleteProgram(); 4063 glDeleteProgram(programObject); 4064 destroyGLES(); 4065 return getError(env, glError); 4066} 4067 4068static napi_value GLProgramUniformMatrix4x2fv(napi_env env, napi_callback_info info) 4069{ 4070 initGLES(); 4071 GLuint programObject = initProgram(); 4072 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4073 GLfloat matrix[MATRIX_8] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10}; 4074 glProgramUniformMatrix4x2fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 4075 GLenum glError = glGetError(); 4076 deleteProgram(); 4077 glDeleteProgram(programObject); 4078 destroyGLES(); 4079 return getError(env, glError); 4080} 4081 4082static napi_value GLProgramUniformMatrix4x3fv(napi_env env, napi_callback_info info) 4083{ 4084 initGLES(); 4085 GLuint programObject = initProgram(); 4086 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4087 GLfloat matrix[MATRIX_12] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, 4088 CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00}; 4089 glProgramUniformMatrix4x3fv(programObject, uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 4090 GLenum glError = glGetError(); 4091 deleteProgram(); 4092 glDeleteProgram(programObject); 4093 destroyGLES(); 4094 return getError(env, glError); 4095} 4096 4097static napi_value GLPushDebugGroup(napi_env env, napi_callback_info info) 4098{ 4099 initGLES(); 4100 glEnable(GL_DEBUG_OUTPUT); 4101 glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, CREAT_NUM_ONE, FAILED, "Render Group"); 4102 GLenum glError = glGetError(); 4103 glPopDebugGroup(); 4104 glDisable(GL_DEBUG_OUTPUT); 4105 destroyGLES(); 4106 return getError(env, glError); 4107} 4108 4109static napi_value GLReadBuffer(napi_env env, napi_callback_info info) 4110{ 4111 initGLES(); 4112 glReadBuffer(GL_BACK); 4113 GLenum glError = glGetError(); 4114 destroyGLES(); 4115 return getError(env, glError); 4116} 4117 4118static napi_value GLReadnPixels(napi_env env, napi_callback_info info) 4119{ 4120 initGLES(); 4121 GLubyte *pixelData = new GLubyte[MATRIX_4 * MATRIX_4 * MATRIX_4]; 4122 glReadnPixels(INT_INIT_VAL, INT_INIT_VAL, MATRIX_4, MATRIX_4, GL_RGBA, GL_UNSIGNED_BYTE, 4123 MATRIX_4 * MATRIX_4 * MATRIX_4, pixelData); 4124 GLenum glError = glGetError(); 4125 destroyGLES(); 4126 return getError(env, glError); 4127} 4128 4129static napi_value GLReadPixels(napi_env env, napi_callback_info info) 4130{ 4131 initGLES(); 4132 GLubyte *pixels = new GLubyte[MATRIX_4 * MATRIX_4 * MATRIX_4]; 4133 glReadPixels(INT_INIT_VAL, INT_INIT_VAL, MATRIX_4, MATRIX_4, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 4134 GLenum glError = glGetError(); 4135 destroyGLES(); 4136 return getError(env, glError); 4137} 4138 4139static napi_value GLReleaseShaderCompiler(napi_env env, napi_callback_info info) 4140{ 4141 initGLES(); 4142 GLuint shader = glCreateShader(GL_VERTEX_SHADER); 4143 glShaderSource(shader, CREAT_NUM_ONE, &vertexShaderSource, nullptr); 4144 glCompileShader(shader); 4145 glReleaseShaderCompiler(); 4146 GLenum glError = glGetError(); 4147 glDeleteShader(shader); 4148 destroyGLES(); 4149 return getError(env, glError); 4150} 4151 4152static napi_value GLRenderbufferStorage(napi_env env, napi_callback_info info) 4153{ 4154 initGLES(); 4155 GLuint renderbuffer = INT_INIT_VAL; 4156 glGenRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 4157 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); 4158 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, INIT_WIDTH, INIT_WIDTH); 4159 GLenum glError = glGetError(); 4160 glDeleteRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 4161 destroyGLES(); 4162 return getError(env, glError); 4163} 4164 4165static napi_value GLRenderbufferStorageMultisample(napi_env env, napi_callback_info info) 4166{ 4167 initGLES(); 4168 GLuint renderbuffer = INT_INIT_VAL; 4169 glGenRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 4170 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); 4171 glRenderbufferStorageMultisample(GL_RENDERBUFFER, SAMPLES, GL_RGBA8, INIT_WIDTH, INIT_WIDTH); 4172 GLenum glError = glGetError(); 4173 glDeleteRenderbuffers(CREAT_NUM_ONE, &renderbuffer); 4174 destroyGLES(); 4175 return getError(env, glError); 4176} 4177 4178static napi_value GLResumeTransformFeedback(napi_env env, napi_callback_info info) 4179{ 4180 initGLES(); 4181 GLuint array; 4182 GLuint buffer; 4183 GLuint feedbackBuffer; 4184 GLuint tbBuffer; 4185 glGenBuffers(CREAT_NUM_ONE, &tbBuffer); 4186 glGenBuffers(CREAT_NUM_ONE, &feedbackBuffer); 4187 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 4188 glUseProgram(program); 4189 GLuint transformFeedback; 4190 glGenTransformFeedbacks(CREAT_NUM_ONE, &transformFeedback); 4191 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback); 4192 glGenVertexArrays(CREAT_NUM_ONE, &array); 4193 glGenBuffers(CREAT_NUM_ONE, &buffer); 4194 glBindVertexArray(array); 4195 glBindBuffer(GL_ARRAY_BUFFER, buffer); 4196 4197 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, INT_INIT_VAL, feedbackBuffer); 4198 glEnable(GL_RASTERIZER_DISCARD); 4199 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, INT_INIT_VAL, tbBuffer); 4200 glTransformFeedbackVaryings(program, VARYING_NUM, (const char*[]){"gl_Position", "vColor"}, GL_SEPARATE_ATTRIBS); 4201 glLinkProgram(program); 4202 4203 glBeginTransformFeedback(GL_POINTS); 4204 glPauseTransformFeedback(); 4205 glResumeTransformFeedback(); 4206 GLenum glError = glGetError(); 4207 4208 deleteProgram(); 4209 glDeleteProgram(program); 4210 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 4211 glDeleteBuffers(CREAT_NUM_ONE, &feedbackBuffer); 4212 glDeleteVertexArrays(CREAT_NUM_ONE, &array); 4213 destroyGLES(); 4214 return getError(env, glError); 4215} 4216 4217static napi_value GLSampleCoverage(napi_env env, napi_callback_info info) 4218{ 4219 initGLES(); 4220 glSampleCoverage(CLEAR_10, GL_TRUE); 4221 GLenum glError = glGetError(); 4222 destroyGLES(); 4223 return getError(env, glError); 4224} 4225 4226static napi_value GLSampleMaski(napi_env env, napi_callback_info info) 4227{ 4228 initGLES(); 4229 glSampleMaski(INT_INIT_VAL, GL_TRIANGLE_STRIP); 4230 GLenum glError = glGetError(); 4231 destroyGLES(); 4232 return getError(env, glError); 4233} 4234 4235static napi_value GLSamplerParameterf(napi_env env, napi_callback_info info) 4236{ 4237 initGLES(); 4238 GLuint sampler = INT_INIT_VAL; 4239 glGenSamplers(CREAT_NUM_ONE, &sampler); 4240 glSamplerParameterf(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 4241 GLenum glError = glGetError(); 4242 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 4243 destroyGLES(); 4244 return getError(env, glError); 4245} 4246 4247static napi_value GLSamplerParameterfv(napi_env env, napi_callback_info info) 4248{ 4249 initGLES(); 4250 GLfloat params[ARRAY_INDEX_TWO] = {INT_INIT_VAL}; 4251 GLuint sampler = INT_INIT_VAL; 4252 glGenSamplers(CREAT_NUM_ONE, &sampler); 4253 params[ARRAY_INDEX_ZERO] = GL_NEAREST; 4254 params[ARRAY_INDEX_ONE] = GL_LINEAR; 4255 glSamplerParameterfv(sampler, GL_TEXTURE_MIN_FILTER, params); 4256 GLenum glError = glGetError(); 4257 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 4258 destroyGLES(); 4259 return getError(env, glError); 4260} 4261 4262static napi_value GLSamplerParameteri(napi_env env, napi_callback_info info) 4263{ 4264 initGLES(); 4265 GLuint sampler = INT_INIT_VAL; 4266 glGenSamplers(CREAT_NUM_ONE, &sampler); 4267 glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 4268 GLenum glError = glGetError(); 4269 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 4270 destroyGLES(); 4271 return getError(env, glError); 4272} 4273 4274static napi_value GLSamplerParameterIiv(napi_env env, napi_callback_info info) 4275{ 4276 initGLES(); 4277 GLint params[ARRAY_INDEX_TWO] = {INT_INIT_VAL}; 4278 GLuint sampler = INT_INIT_VAL; 4279 glGenSamplers(CREAT_NUM_ONE, &sampler); 4280 params[ARRAY_INDEX_ZERO] = GL_NEAREST; 4281 params[ARRAY_INDEX_ONE] = GL_LINEAR; 4282 glSamplerParameterIiv(sampler, GL_TEXTURE_MAG_FILTER, params); 4283 GLenum glError = glGetError(); 4284 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 4285 destroyGLES(); 4286 return getError(env, glError); 4287} 4288 4289static napi_value GLSamplerParameterIuiv(napi_env env, napi_callback_info info) 4290{ 4291 initGLES(); 4292 GLuint params[ARRAY_INDEX_TWO] = {INT_INIT_VAL}; 4293 GLuint sampler = INT_INIT_VAL; 4294 glGenSamplers(CREAT_NUM_ONE, &sampler); 4295 params[ARRAY_INDEX_ZERO] = GL_NEAREST; 4296 params[ARRAY_INDEX_ONE] = GL_LINEAR; 4297 glSamplerParameterIuiv(sampler, GL_TEXTURE_MAG_FILTER, params); 4298 GLenum glError = glGetError(); 4299 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 4300 destroyGLES(); 4301 return getError(env, glError); 4302} 4303 4304static napi_value GLSamplerParameteriv(napi_env env, napi_callback_info info) 4305{ 4306 initGLES(); 4307 GLint params[ARRAY_INDEX_TWO] = {INT_INIT_VAL}; 4308 GLuint sampler = INT_INIT_VAL; 4309 glGenSamplers(CREAT_NUM_ONE, &sampler); 4310 params[ARRAY_INDEX_ZERO] = GL_NEAREST; 4311 params[ARRAY_INDEX_ONE] = GL_LINEAR; 4312 glSamplerParameteriv(sampler, GL_TEXTURE_MAG_FILTER, params); 4313 GLenum glError = glGetError(); 4314 glDeleteSamplers(CREAT_NUM_ONE, &sampler); 4315 destroyGLES(); 4316 return getError(env, glError); 4317} 4318 4319static napi_value GLScissor(napi_env env, napi_callback_info info) 4320{ 4321 initGLES(); 4322 glEnable(GL_SCISSOR_TEST); 4323 glScissor(IMAGE_WIDTH, IMAGE_HEIGHT, INIT_WIDTH, INIT_HEIGHT); 4324 GLenum glError = glGetError(); 4325 glDisable(GL_SCISSOR_TEST); 4326 destroyGLES(); 4327 return getError(env, glError); 4328} 4329 4330static napi_value GLShaderBinary(napi_env env, napi_callback_info info) 4331{ 4332 initGLES(); 4333 GLubyte binary[TEX_BUF_SIZE] = {INT_INIT_VAL}; 4334 GLuint shader = glCreateShader(GL_FRAGMENT_SHADER); 4335 glShaderBinary(CREAT_NUM_ONE, &shader, INT_INIT_VAL, binary, INT_INIT_VAL); 4336 GLenum glError = glGetError(); 4337 glDeleteShader(shader); 4338 destroyGLES(); 4339 return getError(env, glError); 4340} 4341 4342static napi_value GLShaderSource(napi_env env, napi_callback_info info) 4343{ 4344 initGLES(); 4345 GLuint shader = glCreateShader(GL_VERTEX_SHADER); 4346 glShaderSource(shader, CREAT_NUM_ONE, &vertexShaderSource, nullptr); 4347 GLenum glError = glGetError(); 4348 glDeleteShader(shader); 4349 destroyGLES(); 4350 return getError(env, glError); 4351} 4352 4353static napi_value GLStencilFunc(napi_env env, napi_callback_info info) 4354{ 4355 initGLES(); 4356 glEnable(GL_STENCIL_TEST); 4357 glStencilFunc(GL_ALWAYS, CREAT_NUM_ONE, GL_INVALID_INDEX); 4358 GLenum glError = glGetError(); 4359 destroyGLES(); 4360 return getError(env, glError); 4361} 4362 4363static napi_value GLStencilFuncSeparate(napi_env env, napi_callback_info info) 4364{ 4365 initGLES(); 4366 glEnable(GL_STENCIL_TEST); 4367 glStencilFuncSeparate(GL_FRONT, GL_EQUAL, CREAT_NUM_ONE, GL_INVALID_INDEX); 4368 GLenum glError = glGetError(); 4369 destroyGLES(); 4370 return getError(env, glError); 4371} 4372 4373static napi_value GLStencilMask(napi_env env, napi_callback_info info) 4374{ 4375 initGLES(); 4376 glEnable(GL_STENCIL_TEST); 4377 glStencilMask(CREAT_NUM_ONE); 4378 GLenum glError = glGetError(); 4379 destroyGLES(); 4380 return getError(env, glError); 4381} 4382 4383static napi_value GLStencilMaskSeparate(napi_env env, napi_callback_info info) 4384{ 4385 initGLES(); 4386 glEnable(GL_STENCIL_TEST); 4387 glStencilMaskSeparate(GL_FRONT_AND_BACK, CREAT_NUM_ONE); 4388 GLenum glError = glGetError(); 4389 destroyGLES(); 4390 return getError(env, glError); 4391} 4392 4393static napi_value GLStencilOp(napi_env env, napi_callback_info info) 4394{ 4395 initGLES(); 4396 glEnable(GL_STENCIL_TEST); 4397 glStencilOp(GL_KEEP, GL_ZERO, GL_REPLACE); 4398 GLenum glError = glGetError(); 4399 destroyGLES(); 4400 return getError(env, glError); 4401} 4402 4403static napi_value GLStencilOpSeparate(napi_env env, napi_callback_info info) 4404{ 4405 initGLES(); 4406 glEnable(GL_STENCIL_TEST); 4407 glStencilOpSeparate(GL_FRONT_AND_BACK, GL_KEEP, GL_ZERO, GL_REPLACE); 4408 GLenum glError = glGetError(); 4409 destroyGLES(); 4410 return getError(env, glError); 4411} 4412 4413static napi_value GLTexBuffer(napi_env env, napi_callback_info info) 4414{ 4415 initGLES(); 4416 GLuint texture = INT_INIT_VAL; 4417 GLuint buffer = INT_INIT_VAL; 4418 glGenBuffers(CREAT_NUM_ONE, &buffer); 4419 glBindBuffer(GL_TEXTURE_BUFFER, buffer); 4420 glBufferData(GL_TEXTURE_BUFFER, GL_BUF_SIZE, nullptr, GL_DYNAMIC_DRAW); 4421 glGenTextures(CREAT_NUM_ONE, &texture); 4422 glBindTexture(GL_TEXTURE_BUFFER, texture); 4423 glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, buffer); 4424 GLenum glError = glGetError(); 4425 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 4426 glDeleteTextures(CREAT_NUM_ONE, &texture); 4427 destroyGLES(); 4428 return getError(env, glError); 4429} 4430 4431static napi_value GLTexBufferRange(napi_env env, napi_callback_info info) 4432{ 4433 initGLES(); 4434 GLuint texture = INT_INIT_VAL; 4435 GLuint buffer = INT_INIT_VAL; 4436 glGenBuffers(CREAT_NUM_ONE, &buffer); 4437 glBindBuffer(GL_TEXTURE_BUFFER, buffer); 4438 glBufferData(GL_TEXTURE_BUFFER, GL_BUF_SIZE, nullptr, GL_DYNAMIC_DRAW); 4439 glGenTextures(CREAT_NUM_ONE, &texture); 4440 glBindTexture(GL_TEXTURE_BUFFER, texture); 4441 glTexBufferRange(GL_TEXTURE_BUFFER, GL_R32F, buffer, INT_INIT_VAL, CREAT_NUM_ONE); 4442 GLenum glError = glGetError(); 4443 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 4444 glDeleteTextures(CREAT_NUM_ONE, &texture); 4445 destroyGLES(); 4446 return getError(env, glError); 4447} 4448 4449static napi_value GLTexImage2D(napi_env env, napi_callback_info info) 4450{ 4451 initGLES(); 4452 unsigned char pixels[] = {255, 255, 255, 0, 0, 0, 255, 255, 255, 0, 0, 0}; 4453 GLuint texture = INT_INIT_VAL; 4454 glGenTextures(CREAT_NUM_ONE, &texture); 4455 glBindTexture(GL_TEXTURE_2D, texture); 4456 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, VARYING_NUM, VARYING_NUM, INT_INIT_VAL, GL_RGB, GL_UNSIGNED_BYTE, 4457 pixels); 4458 GLenum glError = glGetError(); 4459 glDeleteTextures(CREAT_NUM_ONE, &texture); 4460 destroyGLES(); 4461 return getError(env, glError); 4462} 4463 4464static napi_value GLTexImage3D(napi_env env, napi_callback_info info) 4465{ 4466 initGLES(); 4467 GLuint texture = INT_INIT_VAL; 4468 glGenTextures(CREAT_NUM_ONE, &texture); 4469 glBindTexture(GL_TEXTURE_3D, texture); 4470 glTexImage3D(GL_TEXTURE_3D, INT_INIT_VAL, GL_RGB, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_DEPTH, INT_INIT_VAL, GL_RGB, 4471 GL_UNSIGNED_BYTE, nullptr); 4472 GLenum glError = glGetError(); 4473 glDeleteTextures(CREAT_NUM_ONE, &texture); 4474 destroyGLES(); 4475 return getError(env, glError); 4476} 4477 4478static napi_value GLTexParameterf(napi_env env, napi_callback_info info) 4479{ 4480 initGLES(); 4481 GLuint texture = INT_INIT_VAL; 4482 glGenTextures(CREAT_NUM_ONE, &texture); 4483 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, CLEAR_10); 4484 GLenum glError = glGetError(); 4485 glDeleteTextures(CREAT_NUM_ONE, &texture); 4486 destroyGLES(); 4487 return getError(env, glError); 4488} 4489 4490static napi_value GLTexParameterfv(napi_env env, napi_callback_info info) 4491{ 4492 initGLES(); 4493 GLuint texture = INT_INIT_VAL; 4494 GLfloat color[] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 4495 glGenTextures(CREAT_NUM_ONE, &texture); 4496 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, color); 4497 GLenum glError = glGetError(); 4498 glDeleteTextures(CREAT_NUM_ONE, &texture); 4499 destroyGLES(); 4500 return getError(env, glError); 4501} 4502 4503static napi_value GLTexParameteri(napi_env env, napi_callback_info info) 4504{ 4505 initGLES(); 4506 GLuint texture = INT_INIT_VAL; 4507 glGenTextures(CREAT_NUM_ONE, &texture); 4508 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, CREAT_NUM_ONE); 4509 GLenum glError = glGetError(); 4510 glDeleteTextures(CREAT_NUM_ONE, &texture); 4511 destroyGLES(); 4512 return getError(env, glError); 4513} 4514 4515static napi_value GLTexParameterIiv(napi_env env, napi_callback_info info) 4516{ 4517 initGLES(); 4518 GLuint texture = INT_INIT_VAL; 4519 GLint color[] = {CREAT_NUM_ONE, CREAT_NUM_ONE, CREAT_NUM_ONE, CREAT_NUM_ONE}; 4520 glGenTextures(CREAT_NUM_ONE, &texture); 4521 glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, color); 4522 GLenum glError = glGetError(); 4523 glDeleteTextures(CREAT_NUM_ONE, &texture); 4524 destroyGLES(); 4525 return getError(env, glError); 4526} 4527 4528static napi_value GLTexParameterIuiv(napi_env env, napi_callback_info info) 4529{ 4530 initGLES(); 4531 GLuint texture = INT_INIT_VAL; 4532 GLuint color[] = {CREAT_NUM_ONE, CREAT_NUM_ONE, CREAT_NUM_ONE, CREAT_NUM_ONE}; 4533 glGenTextures(CREAT_NUM_ONE, &texture); 4534 glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, color); 4535 GLenum glError = glGetError(); 4536 glDeleteTextures(CREAT_NUM_ONE, &texture); 4537 destroyGLES(); 4538 return getError(env, glError); 4539} 4540 4541static napi_value GLTexParameteriv(napi_env env, napi_callback_info info) 4542{ 4543 initGLES(); 4544 GLuint texture = INT_INIT_VAL; 4545 GLint color[] = {CREAT_NUM_ONE, CREAT_NUM_ONE, CREAT_NUM_ONE, CREAT_NUM_ONE}; 4546 glGenTextures(CREAT_NUM_ONE, &texture); 4547 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, color); 4548 GLenum glError = glGetError(); 4549 glDeleteTextures(CREAT_NUM_ONE, &texture); 4550 destroyGLES(); 4551 return getError(env, glError); 4552} 4553 4554static napi_value GLTexStorage2D(napi_env env, napi_callback_info info) 4555{ 4556 initGLES(); 4557 GLuint texture; 4558 glGenTextures(CREAT_NUM_ONE, &texture); 4559 glBindTexture(GL_TEXTURE_2D, texture); 4560 glTexStorage2D(GL_TEXTURE_2D, CREAT_NUM_ONE, GL_RGBA8, IMAGE_WIDTH, IMAGE_HEIGHT); 4561 GLenum glError = glGetError(); 4562 glDeleteTextures(CREAT_NUM_ONE, &texture); 4563 destroyGLES(); 4564 return getError(env, glError); 4565} 4566 4567static napi_value GLTexStorage2DMultisample(napi_env env, napi_callback_info info) 4568{ 4569 initGLES(); 4570 GLuint texture = INT_INIT_VAL; 4571 glGenTextures(CREAT_NUM_ONE, &texture); 4572 glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, texture); 4573 glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, SAMPLES, GL_RGB8, IMAGE_WIDTH, IMAGE_HEIGHT, INT_INIT_VAL); 4574 GLenum glError = glGetError(); 4575 glDeleteTextures(CREAT_NUM_ONE, &texture); 4576 destroyGLES(); 4577 return getError(env, glError); 4578} 4579 4580static napi_value GLTexStorage3D(napi_env env, napi_callback_info info) 4581{ 4582 initGLES(); 4583 GLuint texture = INT_INIT_VAL; 4584 glGenTextures(CREAT_NUM_ONE, &texture); 4585 glBindTexture(GL_TEXTURE_2D_ARRAY, texture); 4586 glTexStorage3D(GL_TEXTURE_2D_ARRAY, IMAGE2D_LEVEL_ONE, GL_RGBA8, INIT_WIDTH, INIT_HEIGHT, VARYING_NUM); 4587 GLenum glError = glGetError(); 4588 glDeleteTextures(CREAT_NUM_ONE, &texture); 4589 destroyGLES(); 4590 return getError(env, glError); 4591} 4592 4593static napi_value GLTexStorage3DMultisample(napi_env env, napi_callback_info info) 4594{ 4595 initGLES(); 4596 GLuint texture = INT_INIT_VAL; 4597 glGenTextures(CREAT_NUM_ONE, &texture); 4598 glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, texture); 4599 glTexStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, CREAT_NUM_ONE, GL_RGBA8, SUB_DATA_SIZE, SUB_DATA_SIZE, 4600 SUB_DATA_SIZE, GL_FALSE); 4601 GLenum glError = glGetError(); 4602 glDeleteTextures(CREAT_NUM_ONE, &texture); 4603 destroyGLES(); 4604 return getError(env, glError); 4605} 4606 4607static napi_value GLTexSubImage2D(napi_env env, napi_callback_info info) 4608{ 4609 initGLES(); 4610 GLuint texture = INT_INIT_VAL; 4611 glGenTextures(CREAT_NUM_ONE, &texture); 4612 glBindTexture(GL_TEXTURE_2D, texture); 4613 glTexImage2D(GL_TEXTURE_2D, INT_INIT_VAL, GL_RGB, VARYING_NUM, VARYING_NUM, INT_INIT_VAL, GL_RGB, GL_UNSIGNED_BYTE, 4614 nullptr); 4615 glTexSubImage2D(GL_TEXTURE_2D, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, VARYING_NUM, VARYING_NUM, GL_RGB, 4616 GL_UNSIGNED_BYTE, nullptr); 4617 GLenum glError = glGetError(); 4618 glDeleteTextures(CREAT_NUM_ONE, &texture); 4619 destroyGLES(); 4620 return getError(env, glError); 4621} 4622 4623static napi_value GLTexSubImage3D(napi_env env, napi_callback_info info) 4624{ 4625 initGLES(); 4626 GLuint texture = INT_INIT_VAL; 4627 glGenTextures(CREAT_NUM_ONE, &texture); 4628 glBindTexture(GL_TEXTURE_2D_ARRAY, texture); 4629 glTexImage3D(GL_TEXTURE_2D_ARRAY, INT_INIT_VAL, GL_RGB, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_DEPTH, INT_INIT_VAL, 4630 GL_RGB, GL_UNSIGNED_BYTE, nullptr); 4631 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, IMAGE_WIDTH, 4632 IMAGE_HEIGHT, IMAGE_DEPTH, GL_RGB, GL_UNSIGNED_BYTE, nullptr); 4633 GLenum glError = glGetError(); 4634 glDeleteTextures(CREAT_NUM_ONE, &texture); 4635 destroyGLES(); 4636 return getError(env, glError); 4637} 4638 4639static napi_value GLTransformFeedbackVaryings(napi_env env, napi_callback_info info) 4640{ 4641 initGLES(); 4642 GLuint programObject = initProgram(); 4643 GLuint feedbackObjId = INT_INIT_VAL; 4644 glGenTransformFeedbacks(CREAT_NUM_ONE, &feedbackObjId); 4645 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedbackObjId); 4646 const char *varyingNames[] = {"outValue"}; 4647 glTransformFeedbackVaryings(programObject, CREAT_NUM_ONE, varyingNames, GL_SEPARATE_ATTRIBS); 4648 GLenum glError = glGetError(); 4649 deleteProgram(); 4650 glDeleteProgram(programObject); 4651 glDeleteTransformFeedbacks(CREAT_NUM_ONE, &feedbackObjId); 4652 destroyGLES(); 4653 return getError(env, glError); 4654} 4655 4656static napi_value GLUniform1f(napi_env env, napi_callback_info info) 4657{ 4658 initGLES(); 4659 GLuint programObject = initProgram(); 4660 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4661 glUseProgram(programObject); 4662 glUniform1f(uniformLocation, CLEAR_10); 4663 GLenum glError = glGetError(); 4664 deleteProgram(); 4665 glDeleteProgram(programObject); 4666 destroyGLES(); 4667 return getError(env, glError); 4668} 4669 4670static napi_value GLUniform1fv(napi_env env, napi_callback_info info) 4671{ 4672 initGLES(); 4673 GLuint programObject = initProgram(); 4674 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4675 glUseProgram(programObject); 4676 GLfloat brightness[POINT_LIGHT_COUNT] = {0.8f, 0.2f, 0.6f, 0.4f}; 4677 glUniform1fv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4678 GLenum glError = glGetError(); 4679 deleteProgram(); 4680 glDeleteProgram(programObject); 4681 destroyGLES(); 4682 return getError(env, glError); 4683} 4684 4685static napi_value GLUniform1i(napi_env env, napi_callback_info info) 4686{ 4687 initGLES(); 4688 GLuint programObject = initProgram(); 4689 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4690 glUseProgram(programObject); 4691 glUniform1i(uniformLocation, INT_INIT_VAL); 4692 GLenum glError = glGetError(); 4693 deleteProgram(); 4694 glDeleteProgram(programObject); 4695 destroyGLES(); 4696 return getError(env, glError); 4697} 4698 4699static napi_value GLUniform1iv(napi_env env, napi_callback_info info) 4700{ 4701 initGLES(); 4702 GLuint programObject = initProgram(); 4703 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4704 glUseProgram(programObject); 4705 GLint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4706 glUniform1iv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4707 GLenum glError = glGetError(); 4708 deleteProgram(); 4709 glDeleteProgram(programObject); 4710 destroyGLES(); 4711 return getError(env, glError); 4712} 4713 4714static napi_value GLUniform1ui(napi_env env, napi_callback_info info) 4715{ 4716 initGLES(); 4717 GLuint programObject = initProgram(); 4718 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4719 glUseProgram(programObject); 4720 glUniform1ui(uniformLocation, INT_INIT_VAL); 4721 GLenum glError = glGetError(); 4722 deleteProgram(); 4723 glDeleteProgram(programObject); 4724 destroyGLES(); 4725 return getError(env, glError); 4726} 4727 4728static napi_value GLUniform1uiv(napi_env env, napi_callback_info info) 4729{ 4730 initGLES(); 4731 GLuint programObject = initProgram(); 4732 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4733 glUseProgram(programObject); 4734 GLuint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4735 glUniform1uiv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4736 GLenum glError = glGetError(); 4737 deleteProgram(); 4738 glDeleteProgram(programObject); 4739 destroyGLES(); 4740 return getError(env, glError); 4741} 4742 4743static napi_value GLUniform2f(napi_env env, napi_callback_info info) 4744{ 4745 initGLES(); 4746 GLuint programObject = initProgram(); 4747 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4748 glUseProgram(programObject); 4749 glUniform2f(uniformLocation, CLEAR_10, CLEAR_10); 4750 GLenum glError = glGetError(); 4751 deleteProgram(); 4752 glDeleteProgram(programObject); 4753 destroyGLES(); 4754 return getError(env, glError); 4755} 4756 4757static napi_value GLUniform2fv(napi_env env, napi_callback_info info) 4758{ 4759 initGLES(); 4760 GLuint programObject = initProgram(); 4761 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4762 glUseProgram(programObject); 4763 GLfloat brightness[POINT_LIGHT_COUNT] = {0.8f, 0.2f, 0.6f, 0.4f}; 4764 glUniform2fv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4765 GLenum glError = glGetError(); 4766 deleteProgram(); 4767 glDeleteProgram(programObject); 4768 destroyGLES(); 4769 return getError(env, glError); 4770} 4771 4772static napi_value GLUniform2i(napi_env env, napi_callback_info info) 4773{ 4774 initGLES(); 4775 GLuint programObject = initProgram(); 4776 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4777 glUseProgram(programObject); 4778 glUniform2i(uniformLocation, INT_INIT_VAL, INT_INIT_VAL); 4779 GLenum glError = glGetError(); 4780 deleteProgram(); 4781 glDeleteProgram(programObject); 4782 destroyGLES(); 4783 return getError(env, glError); 4784} 4785 4786static napi_value GLUniform2iv(napi_env env, napi_callback_info info) 4787{ 4788 initGLES(); 4789 GLuint programObject = initProgram(); 4790 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4791 glUseProgram(programObject); 4792 GLint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4793 glUniform2iv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4794 GLenum glError = glGetError(); 4795 deleteProgram(); 4796 glDeleteProgram(programObject); 4797 destroyGLES(); 4798 return getError(env, glError); 4799} 4800 4801static napi_value GLUniform2ui(napi_env env, napi_callback_info info) 4802{ 4803 initGLES(); 4804 GLuint programObject = initProgram(); 4805 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4806 glUseProgram(programObject); 4807 glUniform2ui(uniformLocation, INT_INIT_VAL, INT_INIT_VAL); 4808 GLenum glError = glGetError(); 4809 deleteProgram(); 4810 glDeleteProgram(programObject); 4811 destroyGLES(); 4812 return getError(env, glError); 4813} 4814 4815static napi_value GLUniform2uiv(napi_env env, napi_callback_info info) 4816{ 4817 initGLES(); 4818 GLuint programObject = initProgram(); 4819 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4820 glUseProgram(programObject); 4821 GLuint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4822 glUniform2uiv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4823 GLenum glError = glGetError(); 4824 deleteProgram(); 4825 glDeleteProgram(programObject); 4826 destroyGLES(); 4827 return getError(env, glError); 4828} 4829 4830static napi_value GLUniform3f(napi_env env, napi_callback_info info) 4831{ 4832 initGLES(); 4833 GLuint programObject = initProgram(); 4834 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4835 glUseProgram(programObject); 4836 glUniform3f(uniformLocation, CLEAR_10, CLEAR_10, CLEAR_10); 4837 GLenum glError = glGetError(); 4838 deleteProgram(); 4839 glDeleteProgram(programObject); 4840 destroyGLES(); 4841 return getError(env, glError); 4842} 4843 4844static napi_value GLUniform3fv(napi_env env, napi_callback_info info) 4845{ 4846 initGLES(); 4847 GLuint programObject = initProgram(); 4848 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4849 glUseProgram(programObject); 4850 GLfloat brightness[POINT_LIGHT_COUNT] = {0.8f, 0.2f, 0.6f, 0.4f}; 4851 glUniform3fv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4852 GLenum glError = glGetError(); 4853 deleteProgram(); 4854 glDeleteProgram(programObject); 4855 destroyGLES(); 4856 return getError(env, glError); 4857} 4858 4859static napi_value GLUniform3i(napi_env env, napi_callback_info info) 4860{ 4861 initGLES(); 4862 GLuint programObject = initProgram(); 4863 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4864 glUseProgram(programObject); 4865 glUniform3i(uniformLocation, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 4866 GLenum glError = glGetError(); 4867 deleteProgram(); 4868 glDeleteProgram(programObject); 4869 destroyGLES(); 4870 return getError(env, glError); 4871} 4872 4873static napi_value GLUniform3iv(napi_env env, napi_callback_info info) 4874{ 4875 initGLES(); 4876 GLuint programObject = initProgram(); 4877 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4878 glUseProgram(programObject); 4879 GLint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4880 glUniform3iv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4881 GLenum glError = glGetError(); 4882 deleteProgram(); 4883 glDeleteProgram(programObject); 4884 destroyGLES(); 4885 return getError(env, glError); 4886} 4887 4888static napi_value GLUniform3ui(napi_env env, napi_callback_info info) 4889{ 4890 initGLES(); 4891 GLuint programObject = initProgram(); 4892 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4893 glUseProgram(programObject); 4894 glUniform3ui(uniformLocation, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 4895 GLenum glError = glGetError(); 4896 deleteProgram(); 4897 glDeleteProgram(programObject); 4898 destroyGLES(); 4899 return getError(env, glError); 4900} 4901 4902static napi_value GLUniform3uiv(napi_env env, napi_callback_info info) 4903{ 4904 initGLES(); 4905 GLuint programObject = initProgram(); 4906 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4907 glUseProgram(programObject); 4908 GLuint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4909 glUniform3uiv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4910 GLenum glError = glGetError(); 4911 deleteProgram(); 4912 glDeleteProgram(programObject); 4913 destroyGLES(); 4914 return getError(env, glError); 4915} 4916 4917static napi_value GLUniform4f(napi_env env, napi_callback_info info) 4918{ 4919 initGLES(); 4920 GLuint programObject = initProgram(); 4921 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4922 glUseProgram(programObject); 4923 glUniform4f(uniformLocation, CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10); 4924 GLenum glError = glGetError(); 4925 deleteProgram(); 4926 glDeleteProgram(programObject); 4927 destroyGLES(); 4928 return getError(env, glError); 4929} 4930 4931static napi_value GLUniform4fv(napi_env env, napi_callback_info info) 4932{ 4933 initGLES(); 4934 GLuint programObject = initProgram(); 4935 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4936 glUseProgram(programObject); 4937 GLfloat brightness[POINT_LIGHT_COUNT] = {0.8f, 0.2f, 0.6f, 0.4f}; 4938 glUniform4fv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4939 GLenum glError = glGetError(); 4940 deleteProgram(); 4941 glDeleteProgram(programObject); 4942 destroyGLES(); 4943 return getError(env, glError); 4944} 4945 4946static napi_value GLUniform4i(napi_env env, napi_callback_info info) 4947{ 4948 initGLES(); 4949 GLuint programObject = initProgram(); 4950 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4951 glUseProgram(programObject); 4952 glUniform4i(uniformLocation, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 4953 GLenum glError = glGetError(); 4954 deleteProgram(); 4955 glDeleteProgram(programObject); 4956 destroyGLES(); 4957 return getError(env, glError); 4958} 4959 4960static napi_value GLUniform4iv(napi_env env, napi_callback_info info) 4961{ 4962 initGLES(); 4963 GLuint programObject = initProgram(); 4964 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4965 glUseProgram(programObject); 4966 GLint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4967 glUniform4iv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4968 GLenum glError = glGetError(); 4969 deleteProgram(); 4970 glDeleteProgram(programObject); 4971 destroyGLES(); 4972 return getError(env, glError); 4973} 4974 4975static napi_value GLUniform4ui(napi_env env, napi_callback_info info) 4976{ 4977 initGLES(); 4978 GLuint programObject = initProgram(); 4979 GLint uniformLocation = glGetUniformLocation(programObject, "u_brightness"); 4980 glUseProgram(programObject); 4981 glUniform4ui(uniformLocation, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 4982 GLenum glError = glGetError(); 4983 deleteProgram(); 4984 glDeleteProgram(programObject); 4985 destroyGLES(); 4986 return getError(env, glError); 4987} 4988 4989static napi_value GLUniform4uiv(napi_env env, napi_callback_info info) 4990{ 4991 initGLES(); 4992 GLuint programObject = initProgram(); 4993 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 4994 glUseProgram(programObject); 4995 GLuint brightness[POINT_LIGHT_COUNT] = {0, 0, 0, 0}; 4996 glUniform4uiv(uniformLocation, POINT_LIGHT_COUNT, brightness); 4997 GLenum glError = glGetError(); 4998 deleteProgram(); 4999 glDeleteProgram(programObject); 5000 destroyGLES(); 5001 return getError(env, glError); 5002} 5003 5004static napi_value GLUniformBlockBinding(napi_env env, napi_callback_info info) 5005{ 5006 initGLES(); 5007 GLuint programObject = initProgram(); 5008 GLuint matricesIndex = glGetUniformBlockIndex(programObject, "MatrixBlock"); 5009 glUniformBlockBinding(programObject, matricesIndex, VARYING_NUM); 5010 GLenum glError = glGetError(); 5011 deleteProgram(); 5012 glDeleteProgram(programObject); 5013 destroyGLES(); 5014 return getError(env, glError); 5015} 5016 5017static napi_value GLUniformMatrix2fv(napi_env env, napi_callback_info info) 5018{ 5019 initGLES(); 5020 GLuint programObject = initProgram(); 5021 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5022 glUseProgram(programObject); 5023 GLfloat matrix[MATRIX_4] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10}; 5024 glUniformMatrix2fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5025 GLenum glError = glGetError(); 5026 deleteProgram(); 5027 glDeleteProgram(programObject); 5028 destroyGLES(); 5029 return getError(env, glError); 5030} 5031 5032static napi_value GLUniformMatrix2x3fv(napi_env env, napi_callback_info info) 5033{ 5034 initGLES(); 5035 GLuint programObject = initProgram(); 5036 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5037 glUseProgram(programObject); 5038 GLfloat matrix[MATRIX_6] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00}; 5039 glUniformMatrix2x3fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5040 GLenum glError = glGetError(); 5041 deleteProgram(); 5042 glDeleteProgram(programObject); 5043 destroyGLES(); 5044 return getError(env, glError); 5045} 5046 5047static napi_value GLUniformMatrix2x4fv(napi_env env, napi_callback_info info) 5048{ 5049 initGLES(); 5050 GLuint programObject = initProgram(); 5051 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5052 glUseProgram(programObject); 5053 GLfloat matrix[MATRIX_8] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_10}; 5054 glUniformMatrix2x4fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5055 GLenum glError = glGetError(); 5056 deleteProgram(); 5057 glDeleteProgram(programObject); 5058 destroyGLES(); 5059 return getError(env, glError); 5060} 5061 5062static napi_value GLUniformMatrix3fv(napi_env env, napi_callback_info info) 5063{ 5064 initGLES(); 5065 GLuint programObject = initProgram(); 5066 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5067 glUseProgram(programObject); 5068 GLfloat matrix[MATRIX_9] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, 5069 CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10}; 5070 glUniformMatrix3fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5071 GLenum glError = glGetError(); 5072 deleteProgram(); 5073 glDeleteProgram(programObject); 5074 destroyGLES(); 5075 return getError(env, glError); 5076} 5077 5078static napi_value GLUniformMatrix3x2fv(napi_env env, napi_callback_info info) 5079{ 5080 initGLES(); 5081 GLuint programObject = initProgram(); 5082 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5083 glUseProgram(programObject); 5084 GLfloat matrix[MATRIX_6] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_00}; 5085 glUniformMatrix3x2fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5086 GLenum glError = glGetError(); 5087 deleteProgram(); 5088 glDeleteProgram(programObject); 5089 destroyGLES(); 5090 return getError(env, glError); 5091} 5092 5093static napi_value GLUniformMatrix3x4fv(napi_env env, napi_callback_info info) 5094{ 5095 initGLES(); 5096 GLuint programObject = initProgram(); 5097 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5098 glUseProgram(programObject); 5099 GLfloat matrix[MATRIX_12] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, 5100 CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00}; 5101 glUniformMatrix3x4fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5102 GLenum glError = glGetError(); 5103 deleteProgram(); 5104 glDeleteProgram(programObject); 5105 destroyGLES(); 5106 return getError(env, glError); 5107} 5108 5109static napi_value GLUniformMatrix4fv(napi_env env, napi_callback_info info) 5110{ 5111 initGLES(); 5112 GLuint programObject = initProgram(); 5113 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5114 glUseProgram(programObject); 5115 GLfloat matrix[MATRIX_16] = {CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_00, 5116 CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10}; 5117 glUniformMatrix4fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5118 GLenum glError = glGetError(); 5119 deleteProgram(); 5120 glDeleteProgram(programObject); 5121 destroyGLES(); 5122 return getError(env, glError); 5123} 5124 5125static napi_value GLUniformMatrix4x2fv(napi_env env, napi_callback_info info) 5126{ 5127 initGLES(); 5128 GLuint programObject = initProgram(); 5129 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5130 glUseProgram(programObject); 5131 GLfloat matrix[MATRIX_8] = { 5132 CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, CLEAR_00, 5133 }; 5134 glUniformMatrix4x2fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5135 GLenum glError = glGetError(); 5136 deleteProgram(); 5137 glDeleteProgram(programObject); 5138 destroyGLES(); 5139 return getError(env, glError); 5140} 5141 5142static napi_value GLUniformMatrix4x3fv(napi_env env, napi_callback_info info) 5143{ 5144 initGLES(); 5145 GLuint programObject = initProgram(); 5146 GLint uniformLocation = glGetUniformLocation(programObject, "u_pointLights[0].brightness"); 5147 glUseProgram(programObject); 5148 GLfloat matrix[MATRIX_12] = { 5149 CLEAR_10, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, 5150 CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_10, CLEAR_00, 5151 }; 5152 glUniformMatrix4x3fv(uniformLocation, CREAT_NUM_ONE, GL_TRUE, matrix); 5153 GLenum glError = glGetError(); 5154 deleteProgram(); 5155 glDeleteProgram(programObject); 5156 destroyGLES(); 5157 return getError(env, glError); 5158} 5159 5160static napi_value GLUnmapBuffer(napi_env env, napi_callback_info info) 5161{ 5162 initGLES(); 5163 GLuint buffer; 5164 glGenBuffers(CREAT_NUM_ONE, &buffer); 5165 glBindBuffer(GL_ARRAY_BUFFER, buffer); 5166 glBufferData(GL_ARRAY_BUFFER, GL_BUF_SIZE, nullptr, GL_DYNAMIC_DRAW); 5167 glMapBufferRange(GL_ARRAY_BUFFER, INT_INIT_VAL, GL_BUF_SIZE, 5168 GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 5169 glFlushMappedBufferRange(GL_ARRAY_BUFFER, INT_INIT_VAL, GL_BUF_SIZE); 5170 GLboolean glRet = glUnmapBuffer(GL_ARRAY_BUFFER); 5171 glDeleteBuffers(CREAT_NUM_ONE, &buffer); 5172 destroyGLES(); 5173 napi_value result = nullptr; 5174 if (GL_TRUE == glRet) { 5175 napi_create_int32(env, SUCCESS, &result); 5176 } else { 5177 napi_create_int32(env, FAILED, &result); 5178 } 5179 return result; 5180} 5181 5182static napi_value GLUseProgram(napi_env env, napi_callback_info info) 5183{ 5184 initGLES(); 5185 GLuint programObject = initProgram(); 5186 glUseProgram(programObject); 5187 GLenum glError = glGetError(); 5188 deleteProgram(); 5189 glDeleteProgram(programObject); 5190 destroyGLES(); 5191 return getError(env, glError); 5192} 5193 5194static napi_value GLUseProgramStages(napi_env env, napi_callback_info info) 5195{ 5196 initGLES(); 5197 GLuint pipeline = INT_INIT_VAL; 5198 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 5199 glBindProgramPipeline(pipeline); 5200 GLuint program = glCreateShaderProgramv(GL_FRAGMENT_SHADER, CREAT_NUM_ONE, &fragmentShaderSource); 5201 glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, program); 5202 GLenum glError = glGetError(); 5203 glDeleteProgram(program); 5204 glDeleteProgramPipelines(CREAT_NUM_ONE, &pipeline); 5205 destroyGLES(); 5206 return getError(env, glError); 5207} 5208 5209static napi_value GLValidateProgram(napi_env env, napi_callback_info info) 5210{ 5211 initGLES(); 5212 GLuint programObject = initProgram(); 5213 glValidateProgram(programObject); 5214 GLenum glError = glGetError(); 5215 deleteProgram(); 5216 glDeleteProgram(programObject); 5217 destroyGLES(); 5218 return getError(env, glError); 5219} 5220 5221static napi_value GLValidateProgramPipeline(napi_env env, napi_callback_info info) 5222{ 5223 initGLES(); 5224 GLuint pipeline = INT_INIT_VAL; 5225 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 5226 glBindProgramPipeline(pipeline); 5227 glValidateProgramPipeline(pipeline); 5228 GLenum glError = glGetError(); 5229 glDeleteProgramPipelines(CREAT_NUM_ONE, &pipeline); 5230 return getError(env, glError); 5231} 5232 5233static napi_value GLVertexAttrib1f(napi_env env, napi_callback_info info) 5234{ 5235 initGLES(); 5236 GLuint programObject = initProgram(); 5237 glUseProgram(programObject); 5238 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5239 glVertexAttrib1f(attribLocation, CLEAR_10); 5240 GLenum glError = glGetError(); 5241 deleteProgram(); 5242 glDeleteProgram(programObject); 5243 destroyGLES(); 5244 return getError(env, glError); 5245} 5246 5247static napi_value GLVertexAttrib1fv(napi_env env, napi_callback_info info) 5248{ 5249 initGLES(); 5250 GLuint programObject = initProgram(); 5251 glUseProgram(programObject); 5252 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5253 GLfloat value[ARRAY_INDEX_ONE] = {CLEAR_10}; 5254 glVertexAttrib1fv(attribLocation, value); 5255 GLenum glError = glGetError(); 5256 deleteProgram(); 5257 glDeleteProgram(programObject); 5258 destroyGLES(); 5259 return getError(env, glError); 5260} 5261 5262static napi_value GLVertexAttrib2f(napi_env env, napi_callback_info info) 5263{ 5264 initGLES(); 5265 GLuint programObject = initProgram(); 5266 glUseProgram(programObject); 5267 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5268 glVertexAttrib2f(attribLocation, CLEAR_10, CLEAR_10); 5269 GLenum glError = glGetError(); 5270 deleteProgram(); 5271 glDeleteProgram(programObject); 5272 destroyGLES(); 5273 return getError(env, glError); 5274} 5275 5276static napi_value GLVertexAttrib2fv(napi_env env, napi_callback_info info) 5277{ 5278 initGLES(); 5279 GLuint programObject = initProgram(); 5280 glUseProgram(programObject); 5281 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5282 GLfloat value[ARRAY_INDEX_TWO] = {CLEAR_10, CLEAR_10}; 5283 glVertexAttrib2fv(attribLocation, value); 5284 GLenum glError = glGetError(); 5285 deleteProgram(); 5286 glDeleteProgram(programObject); 5287 destroyGLES(); 5288 return getError(env, glError); 5289} 5290 5291static napi_value GLVertexAttrib3f(napi_env env, napi_callback_info info) 5292{ 5293 initGLES(); 5294 GLuint programObject = initProgram(); 5295 glUseProgram(programObject); 5296 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5297 glVertexAttrib3f(attribLocation, CLEAR_10, CLEAR_10, CLEAR_10); 5298 GLenum glError = glGetError(); 5299 deleteProgram(); 5300 glDeleteProgram(programObject); 5301 destroyGLES(); 5302 return getError(env, glError); 5303} 5304 5305static napi_value GLVertexAttrib3fv(napi_env env, napi_callback_info info) 5306{ 5307 initGLES(); 5308 GLuint programObject = initProgram(); 5309 glUseProgram(programObject); 5310 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5311 GLfloat value[ARRAY_INDEX_THREE] = {CLEAR_10, CLEAR_10, CLEAR_10}; 5312 glVertexAttrib3fv(attribLocation, value); 5313 GLenum glError = glGetError(); 5314 deleteProgram(); 5315 glDeleteProgram(programObject); 5316 destroyGLES(); 5317 return getError(env, glError); 5318} 5319 5320static napi_value GLVertexAttrib4f(napi_env env, napi_callback_info info) 5321{ 5322 initGLES(); 5323 GLuint programObject = initProgram(); 5324 glUseProgram(programObject); 5325 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5326 glVertexAttrib4f(attribLocation, CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10); 5327 GLenum glError = glGetError(); 5328 deleteProgram(); 5329 glDeleteProgram(programObject); 5330 destroyGLES(); 5331 return getError(env, glError); 5332} 5333 5334static napi_value GLVertexAttrib4fv(napi_env env, napi_callback_info info) 5335{ 5336 initGLES(); 5337 GLuint programObject = initProgram(); 5338 glUseProgram(programObject); 5339 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5340 GLfloat value[ARRAY_INDEX_FORE] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 5341 glVertexAttrib4fv(attribLocation, value); 5342 GLenum glError = glGetError(); 5343 deleteProgram(); 5344 glDeleteProgram(programObject); 5345 destroyGLES(); 5346 return getError(env, glError); 5347} 5348 5349static napi_value GLVertexAttribBinding(napi_env env, napi_callback_info info) 5350{ 5351 initGLES(); 5352 GLuint vao = INT_INIT_VAL; 5353 GLuint vbo = INT_INIT_VAL; 5354 glGenVertexArrays(CREAT_NUM_ONE, &vao); 5355 glBindVertexArray(vao); 5356 glGenBuffers(CREAT_NUM_ONE, &vbo); 5357 glBindBuffer(GL_ARRAY_BUFFER, vbo); 5358 GLfloat vertices[] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 5359 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 5360 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 5361 glVertexAttribFormat(ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, ARRAY_INDEX_ZERO); 5362 glVertexAttribBinding(ARRAY_INDEX_ZERO, ARRAY_INDEX_ZERO); 5363 GLenum glError = glGetError(); 5364 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 5365 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 5366 destroyGLES(); 5367 return getError(env, glError); 5368} 5369 5370static napi_value GLVertexAttribDivisor(napi_env env, napi_callback_info info) 5371{ 5372 initGLES(); 5373 GLuint vao = INT_INIT_VAL; 5374 GLuint vbo = INT_INIT_VAL; 5375 glGenVertexArrays(CREAT_NUM_ONE, &vao); 5376 glBindVertexArray(vao); 5377 glGenBuffers(CREAT_NUM_ONE, &vbo); 5378 glBindBuffer(GL_ARRAY_BUFFER, vbo); 5379 GLfloat vertices[] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 5380 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 5381 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 5382 glVertexAttribPointer(INT_INIT_VAL, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, ARRAY_INDEX_THREE * sizeof(GLfloat), 5383 nullptr); 5384 glVertexAttribDivisor(INT_INIT_VAL, CREAT_NUM_ONE); 5385 GLenum glError = glGetError(); 5386 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 5387 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 5388 destroyGLES(); 5389 return getError(env, glError); 5390} 5391 5392static napi_value GLVertexAttribFormat(napi_env env, napi_callback_info info) 5393{ 5394 initGLES(); 5395 GLuint vao = INT_INIT_VAL; 5396 GLuint vbo = INT_INIT_VAL; 5397 glGenVertexArrays(CREAT_NUM_ONE, &vao); 5398 glBindVertexArray(vao); 5399 glGenBuffers(CREAT_NUM_ONE, &vbo); 5400 glBindBuffer(GL_ARRAY_BUFFER, vbo); 5401 GLfloat vertices[] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 5402 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 5403 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 5404 glVertexAttribFormat(ARRAY_INDEX_ZERO, ARRAY_INDEX_THREE, GL_FLOAT, GL_FALSE, ARRAY_INDEX_ZERO); 5405 GLenum glError = glGetError(); 5406 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 5407 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 5408 destroyGLES(); 5409 return getError(env, glError); 5410} 5411 5412static napi_value GLVertexAttribI4i(napi_env env, napi_callback_info info) 5413{ 5414 initGLES(); 5415 GLuint programObject = initProgram(); 5416 glUseProgram(programObject); 5417 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5418 glVertexAttribI4i(attribLocation, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 5419 GLenum glError = glGetError(); 5420 deleteProgram(); 5421 glDeleteProgram(programObject); 5422 destroyGLES(); 5423 return getError(env, glError); 5424} 5425 5426static napi_value GLVertexAttribI4iv(napi_env env, napi_callback_info info) 5427{ 5428 initGLES(); 5429 GLuint programObject = initProgram(); 5430 glUseProgram(programObject); 5431 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5432 GLint value[ARRAY_INDEX_FORE] = {INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL}; 5433 glVertexAttribI4iv(attribLocation, value); 5434 GLenum glError = glGetError(); 5435 deleteProgram(); 5436 glDeleteProgram(programObject); 5437 destroyGLES(); 5438 return getError(env, glError); 5439} 5440 5441static napi_value GLVertexAttribI4ui(napi_env env, napi_callback_info info) 5442{ 5443 initGLES(); 5444 GLuint programObject = initProgram(); 5445 glUseProgram(programObject); 5446 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5447 glVertexAttribI4ui(attribLocation, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL); 5448 GLenum glError = glGetError(); 5449 deleteProgram(); 5450 glDeleteProgram(programObject); 5451 destroyGLES(); 5452 return getError(env, glError); 5453} 5454 5455static napi_value GLVertexAttribI4uiv(napi_env env, napi_callback_info info) 5456{ 5457 initGLES(); 5458 GLuint programObject = initProgram(); 5459 glUseProgram(programObject); 5460 GLint attribLocation = glGetAttribLocation(programObject, "vPosition"); 5461 GLuint value[ARRAY_INDEX_FORE] = {INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL}; 5462 glVertexAttribI4uiv(attribLocation, value); 5463 GLenum glError = glGetError(); 5464 deleteProgram(); 5465 glDeleteProgram(programObject); 5466 destroyGLES(); 5467 return getError(env, glError); 5468} 5469 5470static napi_value GLVertexAttribIFormat(napi_env env, napi_callback_info info) 5471{ 5472 initGLES(); 5473 GLuint vao = INT_INIT_VAL; 5474 GLuint vbo = INT_INIT_VAL; 5475 glGenVertexArrays(CREAT_NUM_ONE, &vao); 5476 glBindVertexArray(vao); 5477 glGenBuffers(CREAT_NUM_ONE, &vbo); 5478 glBindBuffer(GL_ARRAY_BUFFER, vbo); 5479 GLfloat vertices[] = {CLEAR_10, CLEAR_10, CLEAR_10, CLEAR_10}; 5480 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 5481 glEnableVertexAttribArray(ARRAY_INDEX_ZERO); 5482 glVertexAttribIFormat(INT_INIT_VAL, ARRAY_INDEX_FORE, GL_INT, INT_INIT_VAL); 5483 GLenum glError = glGetError(); 5484 glDeleteBuffers(CREAT_NUM_ONE, &vbo); 5485 glDeleteVertexArrays(CREAT_NUM_ONE, &vao); 5486 destroyGLES(); 5487 return getError(env, glError); 5488} 5489 5490static napi_value GLVertexAttribIPointer(napi_env env, napi_callback_info info) 5491{ 5492 initGLES(); 5493 GLint vertices[] = {INT_INIT_VAL, INT_INIT_VAL, INT_INIT_VAL}; 5494 GLuint VAO = INT_INIT_VAL; 5495 GLuint VBO = INT_INIT_VAL; 5496 glGenVertexArrays(CREAT_NUM_ONE, &VAO); 5497 glBindVertexArray(VAO); 5498 glGenBuffers(CREAT_NUM_ONE, &VBO); 5499 glBindBuffer(GL_ARRAY_BUFFER, VBO); 5500 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 5501 glVertexAttribIPointer(INT_INIT_VAL, MATRIX_3, GL_INT, MATRIX_3 * sizeof(GLint), nullptr); 5502 GLenum glError = glGetError(); 5503 glDeleteBuffers(CREAT_NUM_ONE, &VBO); 5504 glDeleteVertexArrays(CREAT_NUM_ONE, &VAO); 5505 destroyGLES(); 5506 return getError(env, glError); 5507} 5508 5509static napi_value GLVertexAttribPointer(napi_env env, napi_callback_info info) 5510{ 5511 initGLES(); 5512 GLfloat vertices[] = {CLEAR_00, 0.5f, CLEAR_00, -0.5f, -0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00}; 5513 GLuint VAO = INT_INIT_VAL; 5514 GLuint VBO = INT_INIT_VAL; 5515 glGenVertexArrays(CREAT_NUM_ONE, &VAO); 5516 glBindVertexArray(VAO); 5517 glGenBuffers(CREAT_NUM_ONE, &VBO); 5518 glBindBuffer(GL_ARRAY_BUFFER, VBO); 5519 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 5520 glVertexAttribPointer(INT_INIT_VAL, ATTRIB_SIZE, GL_FLOAT, GL_FALSE, INT_INIT_VAL, INT_INIT_VAL); 5521 GLenum glError = glGetError(); 5522 glDeleteBuffers(CREAT_NUM_ONE, &VBO); 5523 glDeleteVertexArrays(CREAT_NUM_ONE, &VAO); 5524 destroyGLES(); 5525 return getError(env, glError); 5526} 5527 5528static napi_value GLVertexBindingDivisor(napi_env env, napi_callback_info info) 5529{ 5530 initGLES(); 5531 GLfloat vertices[] = {CLEAR_00, 0.5f, CLEAR_00, -0.5f, -0.5f, CLEAR_00, 0.5f, -0.5f, CLEAR_00}; 5532 GLuint VAO = INT_INIT_VAL; 5533 GLuint VBO = INT_INIT_VAL; 5534 glGenVertexArrays(CREAT_NUM_ONE, &VAO); 5535 glBindVertexArray(VAO); 5536 glGenBuffers(CREAT_NUM_ONE, &VBO); 5537 glBindBuffer(GL_ARRAY_BUFFER, VBO); 5538 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 5539 glVertexAttribPointer(INT_INIT_VAL, ATTRIB_SIZE, GL_FLOAT, GL_FALSE, INT_INIT_VAL, INT_INIT_VAL); 5540 glVertexBindingDivisor(INT_INIT_VAL, CREAT_NUM_ONE); 5541 GLenum glError = glGetError(); 5542 glDeleteBuffers(CREAT_NUM_ONE, &VBO); 5543 glDeleteVertexArrays(CREAT_NUM_ONE, &VAO); 5544 destroyGLES(); 5545 return getError(env, glError); 5546} 5547 5548static napi_value GLViewport(napi_env env, napi_callback_info info) 5549{ 5550 initGLES(); 5551 glViewport(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_HEIGHT); 5552 GLenum glError = glGetError(); 5553 destroyGLES(); 5554 return getError(env, glError); 5555} 5556 5557static napi_value GLWaitSync(napi_env env, napi_callback_info info) 5558{ 5559 initGLES(); 5560 GLsync syncObject = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, INT_INIT_VAL); 5561 glWaitSync(syncObject, INT_INIT_VAL, GL_TIMEOUT_IGNORED); 5562 GLenum glError = glGetError(); 5563 glDeleteSync(syncObject); 5564 destroyGLES(); 5565 return getError(env, glError); 5566} 5567 5568static napi_value GLGetProgramPipelineInfoLog(napi_env env, napi_callback_info info) 5569{ 5570 initGLES(); 5571 GLuint pipeline = INT_INIT_VAL; 5572 glGenProgramPipelines(PIPELINES_NUM_ONE, &pipeline); 5573 glBindProgramPipeline(pipeline); 5574 GLuint program = glCreateShaderProgramv(GL_FRAGMENT_SHADER, CREAT_NUM_ONE, &fragmentShaderSource); 5575 glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, program); 5576 GLchar log[256]; 5577 GLsizei length; 5578 glGetProgramPipelineInfoLog(pipeline, GL_BUF_SIZE, &length, log); 5579 GLenum glError = glGetError(); 5580 glDeleteProgramPipelines(CREAT_NUM_ONE, &pipeline); 5581 glDeleteProgram(program); 5582 destroyGLES(); 5583 return getError(env, glError); 5584} 5585 5586static napi_value GLGetActiveUniform(napi_env env, napi_callback_info info) 5587{ 5588 initGLES(); 5589 GLenum glError = GL_NO_ERROR; 5590 GLuint program = initProgram(vertexSource, fragmentSource); 5591 GLint activeUniformCount; 5592 glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &activeUniformCount); 5593 GLchar uniformName[SUB_DATA_SIZE]; 5594 GLsizei length; 5595 GLint size; 5596 GLenum type; 5597 if (activeUniformCount > 0) { 5598 glGetActiveUniform(program, ARRAY_INDEX_ZERO, SUB_DATA_SIZE, &length, &size, &type, uniformName); 5599 glError = glGetError(); 5600 } 5601 deleteProgram(); 5602 glDeleteProgram(program); 5603 destroyGLES(); 5604 return getError(env, glError); 5605} 5606 5607static napi_value GLGetActiveUniformBlockiv(napi_env env, napi_callback_info info) 5608{ 5609 initGLES(); 5610 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 5611 GLuint blockIndex = glGetUniformBlockIndex(program, "MatrixBlock"); 5612 GLint param; 5613 glGetActiveUniformBlockiv(program, blockIndex, GL_UNIFORM_BLOCK_NAME_LENGTH, ¶m); 5614 GLenum glError = glGetError(); 5615 deleteProgram(); 5616 glDeleteProgram(program); 5617 destroyGLES(); 5618 return getError(env, glError); 5619} 5620 5621static napi_value GLGetActiveUniformBlockName(napi_env env, napi_callback_info info) 5622{ 5623 initGLES(); 5624 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 5625 GLuint blockIndex = glGetUniformBlockIndex(program, "MatrixBlock"); 5626 GLint nameLen; 5627 glGetActiveUniformBlockiv(program, blockIndex, GL_UNIFORM_BLOCK_NAME_LENGTH, &nameLen); 5628 GLsizei length; 5629 GLchar blockName[nameLen]; 5630 glGetActiveUniformBlockName(program, blockIndex, nameLen, &length, blockName); 5631 GLenum glError = glGetError(); 5632 deleteProgram(); 5633 glDeleteProgram(program); 5634 destroyGLES(); 5635 return getError(env, glError); 5636} 5637 5638static napi_value GLGetActiveUniformsiv(napi_env env, napi_callback_info info) 5639{ 5640 initGLES(); 5641 GLuint program = initProgram(vertexShaderSource, fragmentShaderSource); 5642 GLuint blockIndex = glGetUniformBlockIndex(program, "MatrixBlock"); 5643 GLint params; 5644 glGetActiveUniformsiv(program, CREAT_NUM_ONE, &blockIndex, GL_UNIFORM_TYPE, ¶ms); 5645 GLenum glError = glGetError(); 5646 deleteProgram(); 5647 glDeleteProgram(program); 5648 destroyGLES(); 5649 return getError(env, glError); 5650} 5651 5652static napi_value GLGetnUniformfv(napi_env env, napi_callback_info info) 5653{ 5654 initGLES(); 5655 GLuint program = initProgram(vertexSource, fragmentSource); 5656 GLint location = glGetUniformLocation(program, "color"); 5657 GLfloat param; 5658 glGetnUniformfv(program, location, sizeof(GLfloat), ¶m); 5659 GLenum glError = glGetError(); 5660 deleteProgram(); 5661 glDeleteProgram(program); 5662 destroyGLES(); 5663 return getError(env, glError); 5664} 5665static napi_value GLGetnUniformiv(napi_env env, napi_callback_info info) 5666{ 5667 initGLES(); 5668 GLuint program = initProgram(vertexSource, fragmentSource); 5669 GLint location = glGetUniformLocation(program, "color"); 5670 GLint param; 5671 glGetnUniformiv(program, location, sizeof(GLint), ¶m); 5672 GLenum glError = glGetError(); 5673 deleteProgram(); 5674 glDeleteProgram(program); 5675 destroyGLES(); 5676 return getError(env, glError); 5677} 5678static napi_value GLGetnUniformuiv(napi_env env, napi_callback_info info) 5679{ 5680 initGLES(); 5681 GLuint program = initProgram(vertexSource, fragmentSource); 5682 GLint location = glGetUniformLocation(program, "color"); 5683 GLuint param; 5684 glGetnUniformuiv(program, location, sizeof(GLuint), ¶m); 5685 GLenum glError = glGetError(); 5686 deleteProgram(); 5687 glDeleteProgram(program); 5688 destroyGLES(); 5689 return getError(env, glError); 5690} 5691 5692static napi_value GLActiveShaderProgramAbnormal(napi_env env, napi_callback_info info) 5693{ 5694 (void)info; 5695 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5696 initGLES(&eglWindow); 5697 glActiveShaderProgram(GL_ZERO, GL_ZERO); 5698 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glActiveShaderProgram error"); 5699 destroyGLES(&eglWindow); 5700 napi_value result = nullptr; 5701 napi_create_int32(env, FAILED, &result); 5702 return result; 5703} 5704 5705static napi_value GLActiveTextureAbnormal(napi_env env, napi_callback_info info) 5706{ 5707 (void)info; 5708 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5709 initGLES(&eglWindow); 5710 glActiveTexture(GL_ZERO); 5711 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glActiveTexture error"); 5712 destroyGLES(&eglWindow); 5713 napi_value result = nullptr; 5714 napi_create_int32(env, FAILED, &result); 5715 return result; 5716} 5717 5718static napi_value GLAttachShaderAbnormal(napi_env env, napi_callback_info info) 5719{ 5720 (void)info; 5721 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5722 initGLES(&eglWindow); 5723 glAttachShader(GL_ZERO, GL_ZERO); 5724 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glAttachShader error"); 5725 destroyGLES(&eglWindow); 5726 napi_value result = nullptr; 5727 napi_create_int32(env, FAILED, &result); 5728 return result; 5729} 5730 5731static napi_value GLBeginQueryAbnormal(napi_env env, napi_callback_info info) 5732{ 5733 (void)info; 5734 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5735 initGLES(&eglWindow); 5736 glBeginQuery(GL_ZERO, GL_ZERO); 5737 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBeginQuery error"); 5738 destroyGLES(&eglWindow); 5739 napi_value result = nullptr; 5740 napi_create_int32(env, FAILED, &result); 5741 return result; 5742} 5743 5744static napi_value GLBeginTransformFeedbackAbnormal(napi_env env, napi_callback_info info) 5745{ 5746 (void)info; 5747 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5748 initGLES(&eglWindow); 5749 glBeginTransformFeedback(GL_ZERO); 5750 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBeginTransformFeedback error"); 5751 destroyGLES(&eglWindow); 5752 napi_value result = nullptr; 5753 napi_create_int32(env, FAILED, &result); 5754 return result; 5755} 5756 5757static napi_value GLBindAttribLocationAbnormal(napi_env env, napi_callback_info info) 5758{ 5759 (void)info; 5760 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5761 initGLES(&eglWindow); 5762 glBindAttribLocation(GL_ZERO, GL_ZERO, nullptr); 5763 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindAttribLocation error"); 5764 destroyGLES(&eglWindow); 5765 napi_value result = nullptr; 5766 napi_create_int32(env, FAILED, &result); 5767 return result; 5768} 5769 5770static napi_value GLBindBufferAbnormal(napi_env env, napi_callback_info info) 5771{ 5772 (void)info; 5773 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5774 initGLES(&eglWindow); 5775 glBindBuffer(GL_ZERO, GL_ZERO); 5776 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindBuffer error"); 5777 destroyGLES(&eglWindow); 5778 napi_value result = nullptr; 5779 napi_create_int32(env, FAILED, &result); 5780 return result; 5781} 5782 5783static napi_value GLBindBufferBaseAbnormal(napi_env env, napi_callback_info info) 5784{ 5785 (void)info; 5786 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5787 initGLES(&eglWindow); 5788 glBindBufferBase(GL_ZERO, GL_ZERO, GL_ZERO); 5789 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindBufferBase error"); 5790 destroyGLES(&eglWindow); 5791 napi_value result = nullptr; 5792 napi_create_int32(env, FAILED, &result); 5793 return result; 5794} 5795 5796static napi_value GLBindBufferRangeAbnormal(napi_env env, napi_callback_info info) 5797{ 5798 (void)info; 5799 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5800 initGLES(&eglWindow); 5801 glBindBufferRange(GL_ZERO, GL_ZERO, GL_ZERO, GL_ONE, GL_ZERO); 5802 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindBufferRange error"); 5803 destroyGLES(&eglWindow); 5804 napi_value result = nullptr; 5805 napi_create_int32(env, FAILED, &result); 5806 return result; 5807} 5808 5809static napi_value GLBindFramebufferAbnormal(napi_env env, napi_callback_info info) 5810{ 5811 (void)info; 5812 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5813 initGLES(&eglWindow); 5814 glBindFramebuffer(GL_ZERO, GL_ZERO); 5815 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindFramebuffer error"); 5816 destroyGLES(&eglWindow); 5817 napi_value result = nullptr; 5818 napi_create_int32(env, FAILED, &result); 5819 return result; 5820} 5821 5822static napi_value GLBindImageTextureAbnormal(napi_env env, napi_callback_info info) 5823{ 5824 (void)info; 5825 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5826 initGLES(&eglWindow); 5827 glBindImageTexture(GL_ZERO, GL_ZERO, FAILED, GL_FALSE, GL_ZERO, GL_READ_ONLY, GL_RGBA8); 5828 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindImageTexture error"); 5829 destroyGLES(&eglWindow); 5830 napi_value result = nullptr; 5831 napi_create_int32(env, FAILED, &result); 5832 return result; 5833} 5834 5835static napi_value GLBindProgramPipelineAbnormal(napi_env env, napi_callback_info info) 5836{ 5837 (void)info; 5838 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5839 initGLES(&eglWindow); 5840 glBindProgramPipeline(GL_MAX_TEST_NUM); 5841 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindProgramPipeline error"); 5842 destroyGLES(&eglWindow); 5843 napi_value result = nullptr; 5844 napi_create_int32(env, FAILED, &result); 5845 return result; 5846} 5847 5848static napi_value GLBindRenderbufferAbnormal(napi_env env, napi_callback_info info) 5849{ 5850 (void)info; 5851 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5852 initGLES(&eglWindow); 5853 glBindRenderbuffer(GL_ZERO, GL_ZERO); 5854 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindRenderbuffer error"); 5855 destroyGLES(&eglWindow); 5856 napi_value result = nullptr; 5857 napi_create_int32(env, FAILED, &result); 5858 return result; 5859} 5860 5861static napi_value GLBindSamplerAbnormal(napi_env env, napi_callback_info info) 5862{ 5863 (void)info; 5864 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5865 initGLES(&eglWindow); 5866 glBindSampler(GL_MAX_TEST_NUM, GL_ZERO); 5867 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindSampler error"); 5868 destroyGLES(&eglWindow); 5869 napi_value result = nullptr; 5870 napi_create_int32(env, FAILED, &result); 5871 return result; 5872} 5873 5874static napi_value GLBindTextureAbnormal(napi_env env, napi_callback_info info) 5875{ 5876 (void)info; 5877 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5878 initGLES(&eglWindow); 5879 glBindTexture(GL_ZERO, GL_ZERO); 5880 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindTexture error"); 5881 destroyGLES(&eglWindow); 5882 napi_value result = nullptr; 5883 napi_create_int32(env, FAILED, &result); 5884 return result; 5885} 5886 5887static napi_value GLBindTransformFeedbackAbnormal(napi_env env, napi_callback_info info) 5888{ 5889 (void)info; 5890 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5891 initGLES(&eglWindow); 5892 glBindTransformFeedback(GL_ZERO, GL_ZERO); 5893 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindTransformFeedback error"); 5894 destroyGLES(&eglWindow); 5895 napi_value result = nullptr; 5896 napi_create_int32(env, FAILED, &result); 5897 return result; 5898} 5899 5900static napi_value GLBindVertexArrayAbnormal(napi_env env, napi_callback_info info) 5901{ 5902 (void)info; 5903 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5904 initGLES(&eglWindow); 5905 glBindVertexArray(GL_MAX_TEST_NUM); 5906 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindVertexArray error"); 5907 destroyGLES(&eglWindow); 5908 napi_value result = nullptr; 5909 napi_create_int32(env, FAILED, &result); 5910 return result; 5911} 5912 5913static napi_value GLBindVertexBufferAbnormal(napi_env env, napi_callback_info info) 5914{ 5915 (void)info; 5916 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5917 initGLES(&eglWindow); 5918 glBindVertexBuffer(GL_MAX_VERTEX_ATTRIB_BINDINGS, GL_ZERO, FAILED, FAILED); 5919 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBindVertexBuffer error"); 5920 destroyGLES(&eglWindow); 5921 napi_value result = nullptr; 5922 napi_create_int32(env, FAILED, &result); 5923 return result; 5924} 5925 5926static napi_value GLBlendEquationAbnormal(napi_env env, napi_callback_info info) 5927{ 5928 (void)info; 5929 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5930 initGLES(&eglWindow); 5931 glBlendEquation(GL_ZERO); 5932 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendEquation error"); 5933 destroyGLES(&eglWindow); 5934 napi_value result = nullptr; 5935 napi_create_int32(env, FAILED, &result); 5936 return result; 5937} 5938 5939static napi_value GLBlendEquationiAbnormal(napi_env env, napi_callback_info info) 5940{ 5941 (void)info; 5942 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5943 initGLES(&eglWindow); 5944 glBlendEquationi(GL_ZERO, GL_ZERO); 5945 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendEquationi error"); 5946 destroyGLES(&eglWindow); 5947 napi_value result = nullptr; 5948 napi_create_int32(env, FAILED, &result); 5949 return result; 5950} 5951 5952static napi_value GLBlendEquationSeparateAbnormal(napi_env env, napi_callback_info info) 5953{ 5954 (void)info; 5955 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5956 initGLES(&eglWindow); 5957 glBlendEquationSeparate(GL_ZERO, GL_ZERO); 5958 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendEquationSeparate error"); 5959 destroyGLES(&eglWindow); 5960 napi_value result = nullptr; 5961 napi_create_int32(env, FAILED, &result); 5962 return result; 5963} 5964 5965static napi_value GLBlendEquationSeparateiAbnormal(napi_env env, napi_callback_info info) 5966{ 5967 (void)info; 5968 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5969 initGLES(&eglWindow); 5970 glBlendEquationSeparatei(GL_ZERO, GL_ZERO, GL_ZERO); 5971 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendEquationSeparatei error"); 5972 destroyGLES(&eglWindow); 5973 napi_value result = nullptr; 5974 napi_create_int32(env, FAILED, &result); 5975 return result; 5976} 5977 5978static napi_value GLBlendFuncAbnormal(napi_env env, napi_callback_info info) 5979{ 5980 (void)info; 5981 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5982 initGLES(&eglWindow); 5983 glBlendFunc(GL_MAX_TEST_NUM, GL_MAX_TEST_NUM); 5984 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendFunc error"); 5985 destroyGLES(&eglWindow); 5986 napi_value result = nullptr; 5987 napi_create_int32(env, FAILED, &result); 5988 return result; 5989} 5990 5991static napi_value GLBlendFunciAbnormal(napi_env env, napi_callback_info info) 5992{ 5993 (void)info; 5994 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 5995 initGLES(&eglWindow); 5996 glBlendFunci(GL_MAX_DRAW_BUFFERS, GL_MAX_TEST_NUM, GL_MAX_TEST_NUM); 5997 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendFunci error"); 5998 destroyGLES(&eglWindow); 5999 napi_value result = nullptr; 6000 napi_create_int32(env, FAILED, &result); 6001 return result; 6002} 6003 6004static napi_value GLBlendFuncSeparateAbnormal(napi_env env, napi_callback_info info) 6005{ 6006 (void)info; 6007 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6008 initGLES(&eglWindow); 6009 glBlendFuncSeparate(GL_CULL_FACE, GL_CULL_FACE, GL_CULL_FACE, GL_CULL_FACE); 6010 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendFuncSeparate error"); 6011 destroyGLES(&eglWindow); 6012 napi_value result = nullptr; 6013 napi_create_int32(env, FAILED, &result); 6014 return result; 6015} 6016 6017static napi_value GLBlendFuncSeparateiAbnormal(napi_env env, napi_callback_info info) 6018{ 6019 (void)info; 6020 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6021 initGLES(&eglWindow); 6022 glBlendFuncSeparatei(GL_MAX_DRAW_BUFFERS, GL_CULL_FACE, GL_CULL_FACE, GL_CULL_FACE, GL_CULL_FACE); 6023 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlendFuncSeparatei error"); 6024 destroyGLES(&eglWindow); 6025 napi_value result = nullptr; 6026 napi_create_int32(env, FAILED, &result); 6027 return result; 6028} 6029 6030static napi_value GLBlitFramebufferAbnormal(napi_env env, napi_callback_info info) 6031{ 6032 (void)info; 6033 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6034 initGLES(&eglWindow); 6035 glBlitFramebuffer(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 6036 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBlitFramebuffer error"); 6037 destroyGLES(&eglWindow); 6038 napi_value result = nullptr; 6039 napi_create_int32(env, FAILED, &result); 6040 return result; 6041} 6042 6043static napi_value GLBufferDataAbnormal(napi_env env, napi_callback_info info) 6044{ 6045 (void)info; 6046 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6047 initGLES(&eglWindow); 6048 glBufferData(GL_ARRAY_BUFFER, FAILED, nullptr, GL_STREAM_DRAW); 6049 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBufferData error"); 6050 destroyGLES(&eglWindow); 6051 napi_value result = nullptr; 6052 napi_create_int32(env, FAILED, &result); 6053 return result; 6054} 6055 6056static napi_value GLBufferSubDataAbnormal(napi_env env, napi_callback_info info) 6057{ 6058 (void)info; 6059 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6060 initGLES(&eglWindow); 6061 glBufferSubData(GL_ZERO, FAILED, FAILED, nullptr); 6062 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glBufferSubData error"); 6063 destroyGLES(&eglWindow); 6064 napi_value result = nullptr; 6065 napi_create_int32(env, FAILED, &result); 6066 return result; 6067} 6068 6069static napi_value GLCheckFramebufferStatusAbnormal(napi_env env, napi_callback_info info) 6070{ 6071 (void)info; 6072 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6073 initGLES(&eglWindow); 6074 glCheckFramebufferStatus(GL_ZERO); 6075 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCheckFramebufferStatus error"); 6076 destroyGLES(&eglWindow); 6077 napi_value result = nullptr; 6078 napi_create_int32(env, FAILED, &result); 6079 return result; 6080} 6081 6082static napi_value GLClearAbnormal(napi_env env, napi_callback_info info) 6083{ 6084 (void)info; 6085 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6086 initGLES(&eglWindow); 6087 glClear(GL_COLOR_BUFFER_BIT | GL_ONE); 6088 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glClear error"); 6089 destroyGLES(&eglWindow); 6090 napi_value result = nullptr; 6091 napi_create_int32(env, FAILED, &result); 6092 return result; 6093} 6094 6095static napi_value GLClearBufferfiAbnormal(napi_env env, napi_callback_info info) 6096{ 6097 (void)info; 6098 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6099 initGLES(&eglWindow); 6100 glClearBufferfi(GL_ZERO, GL_ZERO, CLEAR_00, GL_ZERO); 6101 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glClearBufferfi error"); 6102 destroyGLES(&eglWindow); 6103 napi_value result = nullptr; 6104 napi_create_int32(env, FAILED, &result); 6105 return result; 6106} 6107 6108static napi_value GLClearBufferfvAbnormal(napi_env env, napi_callback_info info) 6109{ 6110 (void)info; 6111 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6112 initGLES(&eglWindow); 6113 glClearBufferfv(GL_ZERO, GL_ZERO, nullptr); 6114 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "GlClearBufferfvAbnormal error"); 6115 destroyGLES(&eglWindow); 6116 napi_value result = nullptr; 6117 napi_create_int32(env, FAILED, &result); 6118 return result; 6119} 6120 6121static napi_value GLClearBufferivAbnormal(napi_env env, napi_callback_info info) 6122{ 6123 (void)info; 6124 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6125 initGLES(&eglWindow); 6126 glClearBufferiv(GL_ZERO, GL_ZERO, nullptr); 6127 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glClearBufferiv error"); 6128 destroyGLES(&eglWindow); 6129 napi_value result = nullptr; 6130 napi_create_int32(env, FAILED, &result); 6131 return result; 6132} 6133 6134static napi_value GLClearBufferuivAbnormal(napi_env env, napi_callback_info info) 6135{ 6136 (void)info; 6137 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6138 initGLES(&eglWindow); 6139 glClearBufferuiv(GL_ZERO, GL_ZERO, nullptr); 6140 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glClearBufferuiv error"); 6141 destroyGLES(&eglWindow); 6142 napi_value result = nullptr; 6143 napi_create_int32(env, FAILED, &result); 6144 return result; 6145} 6146 6147static napi_value GLClientWaitSyncAbnormal(napi_env env, napi_callback_info info) 6148{ 6149 (void)info; 6150 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6151 initGLES(&eglWindow); 6152 glClientWaitSync(reinterpret_cast<GLsync>(GL_MAX_TEST_NUM), GL_SYNC_FLUSH_COMMANDS_BIT, GL_ZERO); 6153 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glClientWaitSync error"); 6154 destroyGLES(&eglWindow); 6155 napi_value result = nullptr; 6156 napi_create_int32(env, FAILED, &result); 6157 return result; 6158} 6159 6160static napi_value GLColorMaskiAbnormal(napi_env env, napi_callback_info info) 6161{ 6162 (void)info; 6163 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6164 initGLES(&eglWindow); 6165 glColorMaski(GL_MAX_DRAW_BUFFERS, GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 6166 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glColorMaski error"); 6167 destroyGLES(&eglWindow); 6168 napi_value result = nullptr; 6169 napi_create_int32(env, FAILED, &result); 6170 return result; 6171} 6172 6173static napi_value GLCopyBufferSubDataAbnormal(napi_env env, napi_callback_info info) 6174{ 6175 (void)info; 6176 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6177 initGLES(&eglWindow); 6178 glCopyBufferSubData(GL_ZERO, GL_ZERO, FAILED, FAILED, FAILED); 6179 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCopyBufferSubData error"); 6180 destroyGLES(&eglWindow); 6181 napi_value result = nullptr; 6182 napi_create_int32(env, FAILED, &result); 6183 return result; 6184} 6185 6186static napi_value GLCopyImageSubDataAbnormal(napi_env env, napi_callback_info info) 6187{ 6188 (void)info; 6189 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6190 initGLES(&eglWindow); 6191 glCopyImageSubData(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, 6192 GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 6193 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCopyImageSubData error"); 6194 destroyGLES(&eglWindow); 6195 napi_value result = nullptr; 6196 napi_create_int32(env, FAILED, &result); 6197 return result; 6198} 6199 6200static napi_value GLCopyTexImage2DAbnormal(napi_env env, napi_callback_info info) 6201{ 6202 (void)info; 6203 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6204 initGLES(&eglWindow); 6205 glCopyTexImage2D(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 6206 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCopyTexImage2D error"); 6207 destroyGLES(&eglWindow); 6208 napi_value result = nullptr; 6209 napi_create_int32(env, FAILED, &result); 6210 return result; 6211} 6212 6213static napi_value GLCopyTexSubImage2DAbnormal(napi_env env, napi_callback_info info) 6214{ 6215 (void)info; 6216 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6217 initGLES(&eglWindow); 6218 glCopyTexSubImage2D(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 6219 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCopyTexSubImage2D error"); 6220 destroyGLES(&eglWindow); 6221 napi_value result = nullptr; 6222 napi_create_int32(env, FAILED, &result); 6223 return result; 6224} 6225 6226static napi_value GLCreateShaderAbnormal(napi_env env, napi_callback_info info) 6227{ 6228 (void)info; 6229 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6230 initGLES(&eglWindow); 6231 glCreateShader(GL_ZERO); 6232 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCreateShader error"); 6233 destroyGLES(&eglWindow); 6234 napi_value result = nullptr; 6235 napi_create_int32(env, FAILED, &result); 6236 return result; 6237} 6238 6239static napi_value GLCreateShaderProgramvAbnormal(napi_env env, napi_callback_info info) 6240{ 6241 (void)info; 6242 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6243 initGLES(&eglWindow); 6244 glCreateShaderProgramv(GL_ZERO, FAILED, nullptr); 6245 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCreateShaderProgramv error"); 6246 destroyGLES(&eglWindow); 6247 napi_value result = nullptr; 6248 napi_create_int32(env, FAILED, &result); 6249 return result; 6250} 6251 6252static napi_value GLCullFaceAbnormal(napi_env env, napi_callback_info info) 6253{ 6254 (void)info; 6255 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6256 initGLES(&eglWindow); 6257 glCullFace(GL_ZERO); 6258 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCullFace error"); 6259 destroyGLES(&eglWindow); 6260 napi_value result = nullptr; 6261 napi_create_int32(env, FAILED, &result); 6262 return result; 6263} 6264 6265static napi_value GLDebugMessageControlAbnormal(napi_env env, napi_callback_info info) 6266{ 6267 (void)info; 6268 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6269 initGLES(&eglWindow); 6270 glDebugMessageControl(GL_ZERO, GL_ZERO, GL_ZERO, FAILED, nullptr, GL_TRUE); 6271 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDebugMessageControl error"); 6272 destroyGLES(&eglWindow); 6273 napi_value result = nullptr; 6274 napi_create_int32(env, FAILED, &result); 6275 return result; 6276} 6277 6278static napi_value GLDeleteBuffersAbnormal(napi_env env, napi_callback_info info) 6279{ 6280 (void)info; 6281 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6282 initGLES(&eglWindow); 6283 glDeleteBuffers(FAILED, nullptr); 6284 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteBuffers error"); 6285 destroyGLES(&eglWindow); 6286 napi_value result = nullptr; 6287 napi_create_int32(env, FAILED, &result); 6288 return result; 6289} 6290 6291static napi_value GLDeleteFramebuffersAbnormal(napi_env env, napi_callback_info info) 6292{ 6293 (void)info; 6294 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6295 initGLES(&eglWindow); 6296 glDeleteFramebuffers(FAILED, nullptr); 6297 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteFramebuffers error"); 6298 destroyGLES(&eglWindow); 6299 napi_value result = nullptr; 6300 napi_create_int32(env, FAILED, &result); 6301 return result; 6302} 6303 6304static napi_value GLDeleteProgramAbnormal(napi_env env, napi_callback_info info) 6305{ 6306 (void)info; 6307 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6308 initGLES(&eglWindow); 6309 glDeleteProgram(GL_MAX_TEST_NUM); 6310 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteProgram error"); 6311 destroyGLES(&eglWindow); 6312 napi_value result = nullptr; 6313 napi_create_int32(env, FAILED, &result); 6314 return result; 6315} 6316 6317static napi_value GLDeleteProgramPipelinesAbnormal(napi_env env, napi_callback_info info) 6318{ 6319 (void)info; 6320 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6321 initGLES(&eglWindow); 6322 glDeleteProgramPipelines(FAILED, nullptr); 6323 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteProgramPipelines error"); 6324 destroyGLES(&eglWindow); 6325 napi_value result = nullptr; 6326 napi_create_int32(env, FAILED, &result); 6327 return result; 6328} 6329 6330static napi_value GLDeleteQueriesAbnormal(napi_env env, napi_callback_info info) 6331{ 6332 (void)info; 6333 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6334 initGLES(&eglWindow); 6335 glDeleteQueries(FAILED, nullptr); 6336 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteQueries error"); 6337 destroyGLES(&eglWindow); 6338 napi_value result = nullptr; 6339 napi_create_int32(env, FAILED, &result); 6340 return result; 6341} 6342 6343static napi_value GLDeleteRenderbuffersAbnormal(napi_env env, napi_callback_info info) 6344{ 6345 (void)info; 6346 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6347 initGLES(&eglWindow); 6348 glDeleteRenderbuffers(FAILED, nullptr); 6349 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteRenderbuffers error"); 6350 destroyGLES(&eglWindow); 6351 napi_value result = nullptr; 6352 napi_create_int32(env, FAILED, &result); 6353 return result; 6354} 6355 6356static napi_value GLDeleteSamplersAbnormal(napi_env env, napi_callback_info info) 6357{ 6358 (void)info; 6359 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6360 initGLES(&eglWindow); 6361 glDeleteSamplers(FAILED, nullptr); 6362 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteSamplers error"); 6363 destroyGLES(&eglWindow); 6364 napi_value result = nullptr; 6365 napi_create_int32(env, FAILED, &result); 6366 return result; 6367} 6368 6369static napi_value GLDeleteShaderAbnormal(napi_env env, napi_callback_info info) 6370{ 6371 (void)info; 6372 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6373 initGLES(&eglWindow); 6374 glDeleteShader(GL_MAX_TEST_NUM); 6375 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteShader error"); 6376 destroyGLES(&eglWindow); 6377 napi_value result = nullptr; 6378 napi_create_int32(env, FAILED, &result); 6379 return result; 6380} 6381 6382static napi_value GLDeleteSyncAbnormal(napi_env env, napi_callback_info info) 6383{ 6384 (void)info; 6385 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6386 initGLES(&eglWindow); 6387 glDeleteSync(reinterpret_cast<GLsync>(GL_MAX_TEST_NUM)); 6388 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteSync error"); 6389 destroyGLES(&eglWindow); 6390 napi_value result = nullptr; 6391 napi_create_int32(env, FAILED, &result); 6392 return result; 6393} 6394 6395static napi_value GLDeleteTexturesAbnormal(napi_env env, napi_callback_info info) 6396{ 6397 (void)info; 6398 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6399 initGLES(&eglWindow); 6400 glDeleteTextures(FAILED, nullptr); 6401 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteTextures error"); 6402 destroyGLES(&eglWindow); 6403 napi_value result = nullptr; 6404 napi_create_int32(env, FAILED, &result); 6405 return result; 6406} 6407 6408static napi_value GLDeleteTransformFeedbacksAbnormal(napi_env env, napi_callback_info info) 6409{ 6410 (void)info; 6411 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6412 initGLES(&eglWindow); 6413 glDeleteTransformFeedbacks(FAILED, nullptr); 6414 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteTransformFeedbacks error"); 6415 destroyGLES(&eglWindow); 6416 napi_value result = nullptr; 6417 napi_create_int32(env, FAILED, &result); 6418 return result; 6419} 6420 6421static napi_value GLDeleteVertexArraysAbnormal(napi_env env, napi_callback_info info) 6422{ 6423 (void)info; 6424 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6425 initGLES(&eglWindow); 6426 glDeleteVertexArrays(FAILED, nullptr); 6427 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDeleteVertexArrays error"); 6428 destroyGLES(&eglWindow); 6429 napi_value result = nullptr; 6430 napi_create_int32(env, FAILED, &result); 6431 return result; 6432} 6433 6434static napi_value GLDepthFuncAbnormal(napi_env env, napi_callback_info info) 6435{ 6436 (void)info; 6437 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6438 initGLES(&eglWindow); 6439 glDepthFunc(GL_ZERO); 6440 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDepthFunc error"); 6441 destroyGLES(&eglWindow); 6442 napi_value result = nullptr; 6443 napi_create_int32(env, FAILED, &result); 6444 return result; 6445} 6446 6447static napi_value GLDetachShaderAbnormal(napi_env env, napi_callback_info info) 6448{ 6449 (void)info; 6450 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6451 initGLES(&eglWindow); 6452 glDetachShader(GL_MAX_TEST_NUM, GL_MAX_TEST_NUM); 6453 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDetachShader error"); 6454 destroyGLES(&eglWindow); 6455 napi_value result = nullptr; 6456 napi_create_int32(env, FAILED, &result); 6457 return result; 6458} 6459 6460static napi_value GLDisableAbnormal(napi_env env, napi_callback_info info) 6461{ 6462 (void)info; 6463 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6464 initGLES(&eglWindow); 6465 glDisable(GL_ZERO); 6466 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDisable error"); 6467 destroyGLES(&eglWindow); 6468 napi_value result = nullptr; 6469 napi_create_int32(env, FAILED, &result); 6470 return result; 6471} 6472 6473static napi_value GLDisableiAbnormal(napi_env env, napi_callback_info info) 6474{ 6475 (void)info; 6476 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6477 initGLES(&eglWindow); 6478 glDisablei(GL_ZERO, GL_ZERO); 6479 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDisablei error"); 6480 destroyGLES(&eglWindow); 6481 napi_value result = nullptr; 6482 napi_create_int32(env, FAILED, &result); 6483 return result; 6484} 6485 6486static napi_value GLDisableVertexAttribArrayAbnormal(napi_env env, napi_callback_info info) 6487{ 6488 (void)info; 6489 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6490 initGLES(&eglWindow); 6491 glDisableVertexAttribArray(GL_MAX_VERTEX_ATTRIBS); 6492 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDisableVertexAttribArray error"); 6493 destroyGLES(&eglWindow); 6494 napi_value result = nullptr; 6495 napi_create_int32(env, FAILED, &result); 6496 return result; 6497} 6498 6499static napi_value GLDispatchComputeAbnormal(napi_env env, napi_callback_info info) 6500{ 6501 (void)info; 6502 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6503 initGLES(&eglWindow); 6504 glDispatchCompute(GL_MAX_TEST_NUM, GL_MAX_TEST_NUM, GL_MAX_TEST_NUM); 6505 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDispatchCompute error"); 6506 destroyGLES(&eglWindow); 6507 napi_value result = nullptr; 6508 napi_create_int32(env, FAILED, &result); 6509 return result; 6510} 6511 6512static napi_value GLDispatchComputeIndirectAbnormal(napi_env env, napi_callback_info info) 6513{ 6514 (void)info; 6515 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6516 initGLES(&eglWindow); 6517 glDispatchComputeIndirect(FAILED); 6518 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDispatchComputeIndirect error"); 6519 destroyGLES(&eglWindow); 6520 napi_value result = nullptr; 6521 napi_create_int32(env, FAILED, &result); 6522 return result; 6523} 6524 6525static napi_value GLDrawArraysAbnormal(napi_env env, napi_callback_info info) 6526{ 6527 (void)info; 6528 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6529 initGLES(&eglWindow); 6530 glDrawArrays(GL_POINTS, GL_ZERO, FAILED); 6531 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawArrays error"); 6532 destroyGLES(&eglWindow); 6533 napi_value result = nullptr; 6534 napi_create_int32(env, FAILED, &result); 6535 return result; 6536} 6537 6538static napi_value GLDrawArraysIndirectAbnormal(napi_env env, napi_callback_info info) 6539{ 6540 (void)info; 6541 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6542 initGLES(&eglWindow); 6543 glDrawArraysIndirect(GL_ZERO, nullptr); 6544 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawArraysIndirect error"); 6545 destroyGLES(&eglWindow); 6546 napi_value result = nullptr; 6547 napi_create_int32(env, FAILED, &result); 6548 return result; 6549} 6550 6551static napi_value GLDrawArraysInstancedAbnormal(napi_env env, napi_callback_info info) 6552{ 6553 (void)info; 6554 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6555 initGLES(&eglWindow); 6556 glDrawArraysInstanced(GL_POINTS, GL_ZERO, FAILED, FAILED); 6557 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawArraysInstanced error"); 6558 destroyGLES(&eglWindow); 6559 napi_value result = nullptr; 6560 napi_create_int32(env, FAILED, &result); 6561 return result; 6562} 6563 6564static napi_value GLDrawBuffersAbnormal(napi_env env, napi_callback_info info) 6565{ 6566 (void)info; 6567 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6568 initGLES(&eglWindow); 6569 glDrawBuffers(FAILED, nullptr); 6570 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawBuffers error"); 6571 destroyGLES(&eglWindow); 6572 napi_value result = nullptr; 6573 napi_create_int32(env, FAILED, &result); 6574 return result; 6575} 6576 6577static napi_value GLFlushMappedBufferRangeAbnormal(napi_env env, napi_callback_info info) 6578{ 6579 (void)info; 6580 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6581 initGLES(&eglWindow); 6582 glFlushMappedBufferRange(GL_ARRAY_BUFFER, FAILED, FAILED); 6583 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFlushMappedBufferRange error"); 6584 destroyGLES(&eglWindow); 6585 napi_value result = nullptr; 6586 napi_create_int32(env, FAILED, &result); 6587 return result; 6588} 6589 6590static napi_value GLFramebufferParameteriAbnormal(napi_env env, napi_callback_info info) 6591{ 6592 (void)info; 6593 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6594 initGLES(&eglWindow); 6595 glFramebufferParameteri(GL_ZERO, GL_FRAMEBUFFER_DEFAULT_WIDTH, GL_ZERO); 6596 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFramebufferParameteri error"); 6597 destroyGLES(&eglWindow); 6598 napi_value result = nullptr; 6599 napi_create_int32(env, FAILED, &result); 6600 return result; 6601} 6602 6603static napi_value GLFramebufferRenderbufferAbnormal(napi_env env, napi_callback_info info) 6604{ 6605 (void)info; 6606 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6607 initGLES(&eglWindow); 6608 glFramebufferRenderbuffer(GL_ZERO, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, GL_ZERO); 6609 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFramebufferRenderbuffer error"); 6610 destroyGLES(&eglWindow); 6611 napi_value result = nullptr; 6612 napi_create_int32(env, FAILED, &result); 6613 return result; 6614} 6615 6616static napi_value GLFramebufferTextureAbnormal(napi_env env, napi_callback_info info) 6617{ 6618 (void)info; 6619 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6620 initGLES(&eglWindow); 6621 glFramebufferTexture(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 6622 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFramebufferTexture error"); 6623 destroyGLES(&eglWindow); 6624 napi_value result = nullptr; 6625 napi_create_int32(env, FAILED, &result); 6626 return result; 6627} 6628 6629static napi_value GLFramebufferTexture2DAbnormal(napi_env env, napi_callback_info info) 6630{ 6631 (void)info; 6632 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6633 initGLES(&eglWindow); 6634 glFramebufferTexture2D(GL_ZERO, GL_ZERO, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_ZERO, GL_ZERO); 6635 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFramebufferTexture2D error"); 6636 destroyGLES(&eglWindow); 6637 napi_value result = nullptr; 6638 napi_create_int32(env, FAILED, &result); 6639 return result; 6640} 6641 6642static napi_value GLFramebufferTextureLayerAbnormal(napi_env env, napi_callback_info info) 6643{ 6644 (void)info; 6645 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6646 initGLES(&eglWindow); 6647 glFramebufferTextureLayer(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 6648 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFramebufferTextureLayer error"); 6649 destroyGLES(&eglWindow); 6650 napi_value result = nullptr; 6651 napi_create_int32(env, FAILED, &result); 6652 return result; 6653} 6654 6655static napi_value GLFrontFaceAbnormal(napi_env env, napi_callback_info info) 6656{ 6657 (void)info; 6658 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6659 initGLES(&eglWindow); 6660 glFrontFace(GL_ZERO); 6661 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFrontFace error"); 6662 destroyGLES(&eglWindow); 6663 napi_value result = nullptr; 6664 napi_create_int32(env, FAILED, &result); 6665 return result; 6666} 6667 6668static napi_value GLGenBuffersAbnormal(napi_env env, napi_callback_info info) 6669{ 6670 (void)info; 6671 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6672 initGLES(&eglWindow); 6673 glGenBuffers(FAILED, nullptr); 6674 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenBuffers error"); 6675 destroyGLES(&eglWindow); 6676 napi_value result = nullptr; 6677 napi_create_int32(env, FAILED, &result); 6678 return result; 6679} 6680 6681static napi_value GLGenerateMipmapAbnormal(napi_env env, napi_callback_info info) 6682{ 6683 (void)info; 6684 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6685 initGLES(&eglWindow); 6686 glGenerateMipmap(GL_ZERO); 6687 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenerateMipmap error"); 6688 destroyGLES(&eglWindow); 6689 napi_value result = nullptr; 6690 napi_create_int32(env, FAILED, &result); 6691 return result; 6692} 6693 6694static napi_value GLGenFramebuffersAbnormal(napi_env env, napi_callback_info info) 6695{ 6696 (void)info; 6697 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6698 initGLES(&eglWindow); 6699 glGenFramebuffers(FAILED, nullptr); 6700 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenFramebuffers error"); 6701 destroyGLES(&eglWindow); 6702 napi_value result = nullptr; 6703 napi_create_int32(env, FAILED, &result); 6704 return result; 6705} 6706 6707static napi_value GLGenProgramPipelinesAbnormal(napi_env env, napi_callback_info info) 6708{ 6709 (void)info; 6710 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6711 initGLES(&eglWindow); 6712 glGenProgramPipelines(FAILED, nullptr); 6713 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenProgramPipelines error"); 6714 destroyGLES(&eglWindow); 6715 napi_value result = nullptr; 6716 napi_create_int32(env, FAILED, &result); 6717 return result; 6718} 6719 6720static napi_value GLGenQueriesAbnormal(napi_env env, napi_callback_info info) 6721{ 6722 (void)info; 6723 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6724 initGLES(&eglWindow); 6725 glGenQueries(FAILED, nullptr); 6726 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenQueries error"); 6727 destroyGLES(&eglWindow); 6728 napi_value result = nullptr; 6729 napi_create_int32(env, FAILED, &result); 6730 return result; 6731} 6732 6733static napi_value GLGenRenderbuffersAbnormal(napi_env env, napi_callback_info info) 6734{ 6735 (void)info; 6736 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6737 initGLES(&eglWindow); 6738 glGenRenderbuffers(FAILED, nullptr); 6739 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenRenderbuffers error"); 6740 destroyGLES(&eglWindow); 6741 napi_value result = nullptr; 6742 napi_create_int32(env, FAILED, &result); 6743 return result; 6744} 6745 6746static napi_value GLGenSamplersAbnormal(napi_env env, napi_callback_info info) 6747{ 6748 (void)info; 6749 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6750 initGLES(&eglWindow); 6751 glGenSamplers(FAILED, nullptr); 6752 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenSamplers error"); 6753 destroyGLES(&eglWindow); 6754 napi_value result = nullptr; 6755 napi_create_int32(env, FAILED, &result); 6756 return result; 6757} 6758 6759static napi_value GLGenTexturesAbnormal(napi_env env, napi_callback_info info) 6760{ 6761 (void)info; 6762 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6763 initGLES(&eglWindow); 6764 glGenTextures(FAILED, nullptr); 6765 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenTextures error"); 6766 destroyGLES(&eglWindow); 6767 napi_value result = nullptr; 6768 napi_create_int32(env, FAILED, &result); 6769 return result; 6770} 6771 6772static napi_value GLGenTransformFeedbacksAbnormal(napi_env env, napi_callback_info info) 6773{ 6774 (void)info; 6775 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6776 initGLES(&eglWindow); 6777 glGenTransformFeedbacks(FAILED, nullptr); 6778 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenTransformFeedbacks error"); 6779 destroyGLES(&eglWindow); 6780 napi_value result = nullptr; 6781 napi_create_int32(env, FAILED, &result); 6782 return result; 6783} 6784 6785static napi_value GLGenVertexArraysAbnormal(napi_env env, napi_callback_info info) 6786{ 6787 (void)info; 6788 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6789 initGLES(&eglWindow); 6790 glGenVertexArrays(FAILED, nullptr); 6791 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGenVertexArrays error"); 6792 destroyGLES(&eglWindow); 6793 napi_value result = nullptr; 6794 napi_create_int32(env, FAILED, &result); 6795 return result; 6796} 6797 6798static napi_value GLGetActiveAttribAbnormal(napi_env env, napi_callback_info info) 6799{ 6800 (void)info; 6801 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6802 initGLES(&eglWindow); 6803 glGetActiveAttrib(GL_ZERO, GL_ZERO, FAILED, nullptr, nullptr, nullptr, nullptr); 6804 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetActiveAttrib error"); 6805 destroyGLES(&eglWindow); 6806 napi_value result = nullptr; 6807 napi_create_int32(env, FAILED, &result); 6808 return result; 6809} 6810 6811static napi_value GLGetAttachedShadersAbnormal(napi_env env, napi_callback_info info) 6812{ 6813 (void)info; 6814 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6815 initGLES(&eglWindow); 6816 glGetAttachedShaders(GL_ZERO, FAILED, nullptr, nullptr); 6817 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetAttachedShaders error"); 6818 destroyGLES(&eglWindow); 6819 napi_value result = nullptr; 6820 napi_create_int32(env, FAILED, &result); 6821 return result; 6822} 6823 6824static napi_value GLGetAttribLocationAbnormal(napi_env env, napi_callback_info info) 6825{ 6826 (void)info; 6827 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6828 initGLES(&eglWindow); 6829 6830 GLint ret = glGetAttribLocation(GL_ZERO, nullptr); 6831 NAPI_ASSERT(env, ret == FAILED, "glGetAttribLocation error"); 6832 destroyGLES(&eglWindow); 6833 napi_value result = nullptr; 6834 napi_create_int32(env, FAILED, &result); 6835 return result; 6836} 6837 6838static napi_value GLGetBooleani_vAbnormal(napi_env env, napi_callback_info info) 6839{ 6840 (void)info; 6841 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6842 initGLES(&eglWindow); 6843 glGetBooleani_v(GL_ZERO, GL_ZERO, nullptr); 6844 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetBooleani_v error"); 6845 destroyGLES(&eglWindow); 6846 napi_value result = nullptr; 6847 napi_create_int32(env, FAILED, &result); 6848 return result; 6849} 6850 6851static napi_value GLGetBooleanvAbnormal(napi_env env, napi_callback_info info) 6852{ 6853 (void)info; 6854 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6855 initGLES(&eglWindow); 6856 glGetBooleanv(GL_ZERO, nullptr); 6857 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetBooleanv error"); 6858 destroyGLES(&eglWindow); 6859 napi_value result = nullptr; 6860 napi_create_int32(env, FAILED, &result); 6861 return result; 6862} 6863 6864static napi_value GLGetBufferParameteri64vAbnormal(napi_env env, napi_callback_info info) 6865{ 6866 (void)info; 6867 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6868 initGLES(&eglWindow); 6869 glGetBufferParameteri64v(GL_ZERO, GL_ZERO, nullptr); 6870 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetBufferParameteri64v error"); 6871 destroyGLES(&eglWindow); 6872 napi_value result = nullptr; 6873 napi_create_int32(env, FAILED, &result); 6874 return result; 6875} 6876 6877static napi_value GLGetBufferParameterivAbnormal(napi_env env, napi_callback_info info) 6878{ 6879 (void)info; 6880 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6881 initGLES(&eglWindow); 6882 glGetBufferParameteriv(GL_ZERO, GL_ZERO, nullptr); 6883 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetBufferParameteriv error"); 6884 destroyGLES(&eglWindow); 6885 napi_value result = nullptr; 6886 napi_create_int32(env, FAILED, &result); 6887 return result; 6888} 6889 6890static napi_value GLGetBufferPointervAbnormal(napi_env env, napi_callback_info info) 6891{ 6892 (void)info; 6893 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6894 initGLES(&eglWindow); 6895 glGetBufferPointerv(GL_ZERO, GL_ZERO, nullptr); 6896 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetBufferPointerv error"); 6897 destroyGLES(&eglWindow); 6898 napi_value result = nullptr; 6899 napi_create_int32(env, FAILED, &result); 6900 return result; 6901} 6902 6903static napi_value GLGetFloatvAbnormal(napi_env env, napi_callback_info info) 6904{ 6905 (void)info; 6906 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6907 initGLES(&eglWindow); 6908 glGetFloatv(GL_ZERO, nullptr); 6909 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetFloatv error"); 6910 destroyGLES(&eglWindow); 6911 napi_value result = nullptr; 6912 napi_create_int32(env, FAILED, &result); 6913 return result; 6914} 6915 6916static napi_value GLGetFragDataLocationAbnormal(napi_env env, napi_callback_info info) 6917{ 6918 (void)info; 6919 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6920 initGLES(&eglWindow); 6921 glGetFragDataLocation(GL_MAX_TEST_NUM, nullptr); 6922 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetFragDataLocation error"); 6923 destroyGLES(&eglWindow); 6924 napi_value result = nullptr; 6925 napi_create_int32(env, FAILED, &result); 6926 return result; 6927} 6928 6929static napi_value GLGetFramebufferAttachmentParameterivAbnormal(napi_env env, napi_callback_info info) 6930{ 6931 (void)info; 6932 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6933 initGLES(&eglWindow); 6934 glGetFramebufferAttachmentParameteriv(GL_ZERO, GL_ZERO, GL_ZERO, nullptr); 6935 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetFramebufferAttachmentParameteriv error"); 6936 destroyGLES(&eglWindow); 6937 napi_value result = nullptr; 6938 napi_create_int32(env, FAILED, &result); 6939 return result; 6940} 6941 6942static napi_value GLGetFramebufferParameterivAbnormal(napi_env env, napi_callback_info info) 6943{ 6944 (void)info; 6945 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6946 initGLES(&eglWindow); 6947 glGetFramebufferParameteriv(GL_ZERO, GL_ZERO, nullptr); 6948 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetFramebufferParameteriv error"); 6949 destroyGLES(&eglWindow); 6950 napi_value result = nullptr; 6951 napi_create_int32(env, FAILED, &result); 6952 return result; 6953} 6954 6955static napi_value GLGetInteger64i_vAbnormal(napi_env env, napi_callback_info info) 6956{ 6957 (void)info; 6958 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6959 initGLES(&eglWindow); 6960 glGetInteger64i_v(GL_ZERO, GL_ZERO, nullptr); 6961 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetInteger64i_v error"); 6962 destroyGLES(&eglWindow); 6963 napi_value result = nullptr; 6964 napi_create_int32(env, FAILED, &result); 6965 return result; 6966} 6967 6968static napi_value GLGetInteger64vAbnormal(napi_env env, napi_callback_info info) 6969{ 6970 (void)info; 6971 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6972 initGLES(&eglWindow); 6973 glGetInteger64v(GL_ZERO, nullptr); 6974 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetInteger64v error"); 6975 destroyGLES(&eglWindow); 6976 napi_value result = nullptr; 6977 napi_create_int32(env, FAILED, &result); 6978 return result; 6979} 6980 6981static napi_value GLGetIntegeri_vAbnormal(napi_env env, napi_callback_info info) 6982{ 6983 (void)info; 6984 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6985 initGLES(&eglWindow); 6986 glGetIntegeri_v(GL_ZERO, GL_ZERO, nullptr); 6987 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetIntegeri_v error"); 6988 destroyGLES(&eglWindow); 6989 napi_value result = nullptr; 6990 napi_create_int32(env, FAILED, &result); 6991 return result; 6992} 6993 6994static napi_value GLGetIntegervAbnormal(napi_env env, napi_callback_info info) 6995{ 6996 (void)info; 6997 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 6998 initGLES(&eglWindow); 6999 glGetIntegerv(GL_ZERO, nullptr); 7000 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetIntegerv error"); 7001 destroyGLES(&eglWindow); 7002 napi_value result = nullptr; 7003 napi_create_int32(env, FAILED, &result); 7004 return result; 7005} 7006 7007static napi_value GLGetInternalformativAbnormal(napi_env env, napi_callback_info info) 7008{ 7009 (void)info; 7010 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7011 initGLES(&eglWindow); 7012 glGetInternalformativ(GL_ZERO, GL_ZERO, GL_ZERO, FAILED, nullptr); 7013 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetInternalformativ error"); 7014 destroyGLES(&eglWindow); 7015 napi_value result = nullptr; 7016 napi_create_int32(env, FAILED, &result); 7017 return result; 7018} 7019 7020static napi_value GLGetObjectLabelAbnormal(napi_env env, napi_callback_info info) 7021{ 7022 (void)info; 7023 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7024 initGLES(&eglWindow); 7025 glGetObjectLabel(GL_ZERO, GL_ZERO, GL_ZERO, nullptr, nullptr); 7026 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetObjectLabel error"); 7027 destroyGLES(&eglWindow); 7028 napi_value result = nullptr; 7029 napi_create_int32(env, FAILED, &result); 7030 return result; 7031} 7032 7033static napi_value GLGetObjectPtrLabelAbnormal(napi_env env, napi_callback_info info) 7034{ 7035 (void)info; 7036 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7037 initGLES(&eglWindow); 7038 glGetObjectPtrLabel(nullptr, GL_ZERO, nullptr, nullptr); 7039 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetObjectPtrLabel error"); 7040 destroyGLES(&eglWindow); 7041 napi_value result = nullptr; 7042 napi_create_int32(env, FAILED, &result); 7043 return result; 7044} 7045 7046static napi_value GLGetPointervAbnormal(napi_env env, napi_callback_info info) 7047{ 7048 (void)info; 7049 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7050 initGLES(&eglWindow); 7051 glGetPointerv(GL_ZERO, nullptr); 7052 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetPointerv error"); 7053 destroyGLES(&eglWindow); 7054 napi_value result = nullptr; 7055 napi_create_int32(env, FAILED, &result); 7056 return result; 7057} 7058 7059static napi_value GLGetProgramBinaryAbnormal(napi_env env, napi_callback_info info) 7060{ 7061 (void)info; 7062 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7063 initGLES(&eglWindow); 7064 glGetProgramBinary(GL_ZERO, GL_ZERO, nullptr, nullptr, nullptr); 7065 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramBinary error"); 7066 destroyGLES(&eglWindow); 7067 napi_value result = nullptr; 7068 napi_create_int32(env, FAILED, &result); 7069 return result; 7070} 7071 7072static napi_value GLGetProgramInterfaceivAbnormal(napi_env env, napi_callback_info info) 7073{ 7074 (void)info; 7075 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7076 initGLES(&eglWindow); 7077 glGetProgramInterfaceiv(GL_ZERO, GL_ZERO, GL_ZERO, nullptr); 7078 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramInterfaceiv error"); 7079 destroyGLES(&eglWindow); 7080 napi_value result = nullptr; 7081 napi_create_int32(env, FAILED, &result); 7082 return result; 7083} 7084 7085static napi_value GLGetProgramivAbnormal(napi_env env, napi_callback_info info) 7086{ 7087 (void)info; 7088 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7089 initGLES(&eglWindow); 7090 glGetProgramiv(GL_ZERO, GL_ZERO, nullptr); 7091 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramiv error"); 7092 destroyGLES(&eglWindow); 7093 napi_value result = nullptr; 7094 napi_create_int32(env, FAILED, &result); 7095 return result; 7096} 7097 7098static napi_value GLGetProgramPipelineivAbnormal(napi_env env, napi_callback_info info) 7099{ 7100 (void)info; 7101 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7102 initGLES(&eglWindow); 7103 glGetProgramPipelineiv(GL_ZERO, GL_ZERO, nullptr); 7104 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramPipelineiv error"); 7105 destroyGLES(&eglWindow); 7106 napi_value result = nullptr; 7107 napi_create_int32(env, FAILED, &result); 7108 return result; 7109} 7110 7111static napi_value GLGetProgramResourceIndexAbnormal(napi_env env, napi_callback_info info) 7112{ 7113 (void)info; 7114 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7115 initGLES(&eglWindow); 7116 glGetProgramResourceIndex(GL_ZERO, GL_ZERO, nullptr); 7117 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramResourceIndex error"); 7118 destroyGLES(&eglWindow); 7119 napi_value result = nullptr; 7120 napi_create_int32(env, FAILED, &result); 7121 return result; 7122} 7123 7124static napi_value GLGetProgramResourceivAbnormal(napi_env env, napi_callback_info info) 7125{ 7126 (void)info; 7127 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7128 initGLES(&eglWindow); 7129 glGetProgramResourceiv(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, nullptr, GL_ZERO, nullptr, nullptr); 7130 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramResourceiv error"); 7131 destroyGLES(&eglWindow); 7132 napi_value result = nullptr; 7133 napi_create_int32(env, FAILED, &result); 7134 return result; 7135} 7136 7137static napi_value GLGetProgramResourceLocationAbnormal(napi_env env, napi_callback_info info) 7138{ 7139 (void)info; 7140 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7141 initGLES(&eglWindow); 7142 glGetProgramResourceLocation(GL_ZERO, GL_ZERO, nullptr); 7143 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramResourceLocation error"); 7144 destroyGLES(&eglWindow); 7145 napi_value result = nullptr; 7146 napi_create_int32(env, FAILED, &result); 7147 return result; 7148} 7149 7150static napi_value GLGetProgramResourceNameAbnormal(napi_env env, napi_callback_info info) 7151{ 7152 (void)info; 7153 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7154 initGLES(&eglWindow); 7155 glGetProgramResourceName(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, nullptr, nullptr); 7156 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetProgramResourceName error"); 7157 destroyGLES(&eglWindow); 7158 napi_value result = nullptr; 7159 napi_create_int32(env, FAILED, &result); 7160 return result; 7161} 7162 7163static napi_value GLGetQueryivAbnormal(napi_env env, napi_callback_info info) 7164{ 7165 (void)info; 7166 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7167 initGLES(&eglWindow); 7168 glGetQueryiv(GL_ZERO, GL_ZERO, nullptr); 7169 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetQueryiv error"); 7170 destroyGLES(&eglWindow); 7171 napi_value result = nullptr; 7172 napi_create_int32(env, FAILED, &result); 7173 return result; 7174} 7175 7176static napi_value GLGetQueryObjectuivAbnormal(napi_env env, napi_callback_info info) 7177{ 7178 (void)info; 7179 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7180 initGLES(&eglWindow); 7181 glGetQueryObjectuiv(GL_ZERO, GL_ZERO, nullptr); 7182 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetQueryObjectuiv error"); 7183 destroyGLES(&eglWindow); 7184 napi_value result = nullptr; 7185 napi_create_int32(env, FAILED, &result); 7186 return result; 7187} 7188 7189static napi_value GLGetRenderbufferParameterivAbnormal(napi_env env, napi_callback_info info) 7190{ 7191 (void)info; 7192 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7193 initGLES(&eglWindow); 7194 glGetRenderbufferParameteriv(GL_ZERO, GL_ZERO, nullptr); 7195 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetRenderbufferParameteriv error"); 7196 destroyGLES(&eglWindow); 7197 napi_value result = nullptr; 7198 napi_create_int32(env, FAILED, &result); 7199 return result; 7200} 7201 7202static napi_value GLGetSamplerParameterfvAbnormal(napi_env env, napi_callback_info info) 7203{ 7204 (void)info; 7205 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7206 initGLES(&eglWindow); 7207 glGetSamplerParameterfv(GL_ZERO, GL_ZERO, nullptr); 7208 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetSamplerParameterfv error"); 7209 destroyGLES(&eglWindow); 7210 napi_value result = nullptr; 7211 napi_create_int32(env, FAILED, &result); 7212 return result; 7213} 7214 7215static napi_value GLGetSamplerParameterIivAbnormal(napi_env env, napi_callback_info info) 7216{ 7217 (void)info; 7218 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7219 initGLES(&eglWindow); 7220 glGetSamplerParameterIiv(GL_ZERO, GL_ZERO, nullptr); 7221 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetSamplerParameterIiv error"); 7222 destroyGLES(&eglWindow); 7223 napi_value result = nullptr; 7224 napi_create_int32(env, FAILED, &result); 7225 return result; 7226} 7227 7228static napi_value GLGetSamplerParameterIuivAbnormal(napi_env env, napi_callback_info info) 7229{ 7230 (void)info; 7231 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7232 initGLES(&eglWindow); 7233 glGetSamplerParameterIuiv(GL_ZERO, GL_ZERO, nullptr); 7234 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetSamplerParameterIuiv error"); 7235 destroyGLES(&eglWindow); 7236 napi_value result = nullptr; 7237 napi_create_int32(env, FAILED, &result); 7238 return result; 7239} 7240 7241static napi_value GLGetSamplerParameterivAbnormal(napi_env env, napi_callback_info info) 7242{ 7243 (void)info; 7244 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7245 initGLES(&eglWindow); 7246 glGetSamplerParameteriv(GL_ZERO, GL_ZERO, nullptr); 7247 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glGetSamplerParameteriv error"); 7248 destroyGLES(&eglWindow); 7249 napi_value result = nullptr; 7250 napi_create_int32(env, FAILED, &result); 7251 return result; 7252} 7253 7254static napi_value GLUniform1fAbnormal(napi_env env, napi_callback_info info) 7255{ 7256 (void)info; 7257 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7258 initGLES(&eglWindow); 7259 glUniform1f(GL_ZERO, CLEAR_00); 7260 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform1f error"); 7261 destroyGLES(&eglWindow); 7262 napi_value result = nullptr; 7263 napi_create_int32(env, FAILED, &result); 7264 return result; 7265} 7266 7267static napi_value GLUniform1fvAbnormal(napi_env env, napi_callback_info info) 7268{ 7269 (void)info; 7270 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7271 initGLES(&eglWindow); 7272 glUniform1fv(GL_ZERO, FAILED, nullptr); 7273 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform1fv error"); 7274 destroyGLES(&eglWindow); 7275 napi_value result = nullptr; 7276 napi_create_int32(env, FAILED, &result); 7277 return result; 7278} 7279 7280static napi_value GLUniform1iAbnormal(napi_env env, napi_callback_info info) 7281{ 7282 (void)info; 7283 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7284 initGLES(&eglWindow); 7285 glUniform1i(GL_ZERO, GL_ZERO); 7286 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform1i error"); 7287 destroyGLES(&eglWindow); 7288 napi_value result = nullptr; 7289 napi_create_int32(env, FAILED, &result); 7290 return result; 7291} 7292 7293static napi_value GLUniform1ivAbnormal(napi_env env, napi_callback_info info) 7294{ 7295 (void)info; 7296 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7297 initGLES(&eglWindow); 7298 glUniform1iv(GL_ZERO, FAILED, nullptr); 7299 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform1iv error"); 7300 destroyGLES(&eglWindow); 7301 napi_value result = nullptr; 7302 napi_create_int32(env, FAILED, &result); 7303 return result; 7304} 7305 7306static napi_value GLUniform1uiAbnormal(napi_env env, napi_callback_info info) 7307{ 7308 (void)info; 7309 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7310 initGLES(&eglWindow); 7311 glUniform1ui(GL_ZERO, GL_ZERO); 7312 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform1ui error"); 7313 destroyGLES(&eglWindow); 7314 napi_value result = nullptr; 7315 napi_create_int32(env, FAILED, &result); 7316 return result; 7317} 7318 7319static napi_value GLUniform1uivAbnormal(napi_env env, napi_callback_info info) 7320{ 7321 (void)info; 7322 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7323 initGLES(&eglWindow); 7324 glUniform1uiv(GL_ZERO, FAILED, nullptr); 7325 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform1uiv error"); 7326 destroyGLES(&eglWindow); 7327 napi_value result = nullptr; 7328 napi_create_int32(env, FAILED, &result); 7329 return result; 7330} 7331 7332static napi_value GLUniform2fAbnormal(napi_env env, napi_callback_info info) 7333{ 7334 (void)info; 7335 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7336 initGLES(&eglWindow); 7337 glUniform2f(GL_ZERO, CLEAR_00, CLEAR_00); 7338 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform2f error"); 7339 destroyGLES(&eglWindow); 7340 napi_value result = nullptr; 7341 napi_create_int32(env, FAILED, &result); 7342 return result; 7343} 7344 7345static napi_value GLUniform2fvAbnormal(napi_env env, napi_callback_info info) 7346{ 7347 (void)info; 7348 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7349 initGLES(&eglWindow); 7350 glUniform2fv(GL_ZERO, FAILED, nullptr); 7351 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform2fv error"); 7352 destroyGLES(&eglWindow); 7353 napi_value result = nullptr; 7354 napi_create_int32(env, FAILED, &result); 7355 return result; 7356} 7357 7358static napi_value GLUniform2iAbnormal(napi_env env, napi_callback_info info) 7359{ 7360 (void)info; 7361 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7362 initGLES(&eglWindow); 7363 glUniform2i(GL_ZERO, GL_ZERO, GL_ZERO); 7364 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform2i error"); 7365 destroyGLES(&eglWindow); 7366 napi_value result = nullptr; 7367 napi_create_int32(env, FAILED, &result); 7368 return result; 7369} 7370 7371static napi_value GLUniform2ivAbnormal(napi_env env, napi_callback_info info) 7372{ 7373 (void)info; 7374 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7375 initGLES(&eglWindow); 7376 glUniform2iv(GL_ZERO, FAILED, nullptr); 7377 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform2iv error"); 7378 destroyGLES(&eglWindow); 7379 napi_value result = nullptr; 7380 napi_create_int32(env, FAILED, &result); 7381 return result; 7382} 7383 7384static napi_value GLUniform2uiAbnormal(napi_env env, napi_callback_info info) 7385{ 7386 (void)info; 7387 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7388 initGLES(&eglWindow); 7389 glUniform2ui(GL_ZERO, GL_ZERO, GL_ZERO); 7390 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform2ui error"); 7391 destroyGLES(&eglWindow); 7392 napi_value result = nullptr; 7393 napi_create_int32(env, FAILED, &result); 7394 return result; 7395} 7396 7397static napi_value GLUniform2uivAbnormal(napi_env env, napi_callback_info info) 7398{ 7399 (void)info; 7400 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7401 initGLES(&eglWindow); 7402 glUniform2uiv(GL_ZERO, FAILED, nullptr); 7403 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform2uiv error"); 7404 destroyGLES(&eglWindow); 7405 napi_value result = nullptr; 7406 napi_create_int32(env, FAILED, &result); 7407 return result; 7408} 7409 7410static napi_value GLUniform3fAbnormal(napi_env env, napi_callback_info info) 7411{ 7412 (void)info; 7413 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7414 initGLES(&eglWindow); 7415 glUniform3f(GL_ZERO, CLEAR_00, CLEAR_00, CLEAR_00); 7416 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform3f error"); 7417 destroyGLES(&eglWindow); 7418 napi_value result = nullptr; 7419 napi_create_int32(env, FAILED, &result); 7420 return result; 7421} 7422 7423static napi_value GLUniform3fvAbnormal(napi_env env, napi_callback_info info) 7424{ 7425 (void)info; 7426 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7427 initGLES(&eglWindow); 7428 glUniform3fv(GL_ZERO, FAILED, nullptr); 7429 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform3fv error"); 7430 destroyGLES(&eglWindow); 7431 napi_value result = nullptr; 7432 napi_create_int32(env, FAILED, &result); 7433 return result; 7434} 7435 7436static napi_value GLUniform3iAbnormal(napi_env env, napi_callback_info info) 7437{ 7438 (void)info; 7439 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7440 initGLES(&eglWindow); 7441 glUniform3i(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 7442 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform3i error"); 7443 destroyGLES(&eglWindow); 7444 napi_value result = nullptr; 7445 napi_create_int32(env, FAILED, &result); 7446 return result; 7447} 7448 7449static napi_value GLUniform3ivAbnormal(napi_env env, napi_callback_info info) 7450{ 7451 (void)info; 7452 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7453 initGLES(&eglWindow); 7454 glUniform3iv(GL_ZERO, FAILED, nullptr); 7455 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform3iv error"); 7456 destroyGLES(&eglWindow); 7457 napi_value result = nullptr; 7458 napi_create_int32(env, FAILED, &result); 7459 return result; 7460} 7461 7462static napi_value GLUniform3uiAbnormal(napi_env env, napi_callback_info info) 7463{ 7464 (void)info; 7465 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7466 initGLES(&eglWindow); 7467 glUniform3ui(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 7468 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform3ui error"); 7469 destroyGLES(&eglWindow); 7470 napi_value result = nullptr; 7471 napi_create_int32(env, FAILED, &result); 7472 return result; 7473} 7474 7475static napi_value GLUniform3uivAbnormal(napi_env env, napi_callback_info info) 7476{ 7477 (void)info; 7478 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7479 initGLES(&eglWindow); 7480 glUniform3uiv(GL_ZERO, FAILED, nullptr); 7481 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform3uiv error"); 7482 destroyGLES(&eglWindow); 7483 napi_value result = nullptr; 7484 napi_create_int32(env, FAILED, &result); 7485 return result; 7486} 7487 7488static napi_value GLUniform4fAbnormal(napi_env env, napi_callback_info info) 7489{ 7490 (void)info; 7491 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7492 initGLES(&eglWindow); 7493 glUniform4f(GL_ZERO, CLEAR_00, CLEAR_00, CLEAR_00, CLEAR_00); 7494 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform4f error"); 7495 destroyGLES(&eglWindow); 7496 napi_value result = nullptr; 7497 napi_create_int32(env, FAILED, &result); 7498 return result; 7499} 7500 7501static napi_value GLUniform4fvAbnormal(napi_env env, napi_callback_info info) 7502{ 7503 (void)info; 7504 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7505 initGLES(&eglWindow); 7506 glUniform4fv(GL_ZERO, FAILED, nullptr); 7507 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform4fv error"); 7508 destroyGLES(&eglWindow); 7509 napi_value result = nullptr; 7510 napi_create_int32(env, FAILED, &result); 7511 return result; 7512} 7513 7514static napi_value GLUniform4iAbnormal(napi_env env, napi_callback_info info) 7515{ 7516 (void)info; 7517 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7518 initGLES(&eglWindow); 7519 glUniform4i(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 7520 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform4i error"); 7521 destroyGLES(&eglWindow); 7522 napi_value result = nullptr; 7523 napi_create_int32(env, FAILED, &result); 7524 return result; 7525} 7526 7527static napi_value GLUniform4ivAbnormal(napi_env env, napi_callback_info info) 7528{ 7529 (void)info; 7530 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7531 initGLES(&eglWindow); 7532 glUniform4iv(GL_ZERO, FAILED, nullptr); 7533 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform4iv error"); 7534 destroyGLES(&eglWindow); 7535 napi_value result = nullptr; 7536 napi_create_int32(env, FAILED, &result); 7537 return result; 7538} 7539 7540static napi_value GLUniform4uiAbnormal(napi_env env, napi_callback_info info) 7541{ 7542 (void)info; 7543 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7544 initGLES(&eglWindow); 7545 glUniform4ui(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 7546 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform4ui error"); 7547 destroyGLES(&eglWindow); 7548 napi_value result = nullptr; 7549 napi_create_int32(env, FAILED, &result); 7550 return result; 7551} 7552 7553static napi_value GLUniform4uivAbnormal(napi_env env, napi_callback_info info) 7554{ 7555 (void)info; 7556 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7557 initGLES(&eglWindow); 7558 glUniform4uiv(GL_ZERO, FAILED, nullptr); 7559 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniform4uiv error"); 7560 destroyGLES(&eglWindow); 7561 napi_value result = nullptr; 7562 napi_create_int32(env, FAILED, &result); 7563 return result; 7564} 7565 7566static napi_value GLUniformBlockBindingAbnormal(napi_env env, napi_callback_info info) 7567{ 7568 (void)info; 7569 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7570 initGLES(&eglWindow); 7571 glUniformBlockBinding(GL_ZERO, GL_MAX_TEST_NUM, GL_ZERO); 7572 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformBlockBinding error"); 7573 destroyGLES(&eglWindow); 7574 napi_value result = nullptr; 7575 napi_create_int32(env, FAILED, &result); 7576 return result; 7577} 7578 7579static napi_value GLUniformMatrix2fvAbnormal(napi_env env, napi_callback_info info) 7580{ 7581 (void)info; 7582 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7583 initGLES(&eglWindow); 7584 glUniformMatrix2fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7585 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix2fv error"); 7586 destroyGLES(&eglWindow); 7587 napi_value result = nullptr; 7588 napi_create_int32(env, FAILED, &result); 7589 return result; 7590} 7591 7592static napi_value GLUniformMatrix2x3fvAbnormal(napi_env env, napi_callback_info info) 7593{ 7594 (void)info; 7595 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7596 initGLES(&eglWindow); 7597 glUniformMatrix2x3fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7598 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix2x3fv error"); 7599 destroyGLES(&eglWindow); 7600 napi_value result = nullptr; 7601 napi_create_int32(env, FAILED, &result); 7602 return result; 7603} 7604 7605static napi_value GLUniformMatrix2x4fvAbnormal(napi_env env, napi_callback_info info) 7606{ 7607 (void)info; 7608 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7609 initGLES(&eglWindow); 7610 glUniformMatrix2x4fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7611 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix2x4fv error"); 7612 destroyGLES(&eglWindow); 7613 napi_value result = nullptr; 7614 napi_create_int32(env, FAILED, &result); 7615 return result; 7616} 7617 7618static napi_value GLUniformMatrix3fvAbnormal(napi_env env, napi_callback_info info) 7619{ 7620 (void)info; 7621 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7622 initGLES(&eglWindow); 7623 glUniformMatrix3fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7624 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix3fv error"); 7625 destroyGLES(&eglWindow); 7626 napi_value result = nullptr; 7627 napi_create_int32(env, FAILED, &result); 7628 return result; 7629} 7630 7631static napi_value GLUniformMatrix3x2fvAbnormal(napi_env env, napi_callback_info info) 7632{ 7633 (void)info; 7634 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7635 initGLES(&eglWindow); 7636 glUniformMatrix3x2fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7637 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix3x2fv error"); 7638 destroyGLES(&eglWindow); 7639 napi_value result = nullptr; 7640 napi_create_int32(env, FAILED, &result); 7641 return result; 7642} 7643 7644static napi_value GLUniformMatrix3x4fvAbnormal(napi_env env, napi_callback_info info) 7645{ 7646 (void)info; 7647 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7648 initGLES(&eglWindow); 7649 glUniformMatrix3x4fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7650 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix3x4fv error"); 7651 destroyGLES(&eglWindow); 7652 napi_value result = nullptr; 7653 napi_create_int32(env, FAILED, &result); 7654 return result; 7655} 7656 7657static napi_value GLUniformMatrix4fvAbnormal(napi_env env, napi_callback_info info) 7658{ 7659 (void)info; 7660 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7661 initGLES(&eglWindow); 7662 glUniformMatrix4fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7663 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix4fv error"); 7664 destroyGLES(&eglWindow); 7665 napi_value result = nullptr; 7666 napi_create_int32(env, FAILED, &result); 7667 return result; 7668} 7669 7670static napi_value GLUniformMatrix4x2fvAbnormal(napi_env env, napi_callback_info info) 7671{ 7672 (void)info; 7673 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7674 initGLES(&eglWindow); 7675 glUniformMatrix4x2fv(GL_ZERO, GL_ZERO, GL_TRUE, nullptr); 7676 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix4x2fv error"); 7677 destroyGLES(&eglWindow); 7678 napi_value result = nullptr; 7679 napi_create_int32(env, FAILED, &result); 7680 return result; 7681} 7682 7683static napi_value GLUniformMatrix4x3fvAbnormal(napi_env env, napi_callback_info info) 7684{ 7685 (void)info; 7686 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7687 initGLES(&eglWindow); 7688 glUniformMatrix4x3fv(GL_ZERO, FAILED, GL_TRUE, nullptr); 7689 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glUniformMatrix4x3fv error"); 7690 destroyGLES(&eglWindow); 7691 napi_value result = nullptr; 7692 napi_create_int32(env, FAILED, &result); 7693 return result; 7694} 7695 7696static napi_value GLCompileShaderAbnormal(napi_env env, napi_callback_info info) 7697{ 7698 (void)info; 7699 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7700 initGLES(&eglWindow); 7701 glCompileShader(GL_MAX_TEST_NUM); 7702 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCompileShader error"); 7703 destroyGLES(&eglWindow); 7704 napi_value result = nullptr; 7705 napi_create_int32(env, FAILED, &result); 7706 return result; 7707} 7708 7709static napi_value GLCompressedTexImage2DAbnormal(napi_env env, napi_callback_info info) 7710{ 7711 (void)info; 7712 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7713 initGLES(&eglWindow); 7714 glCompressedTexImage2D(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ONE, GL_ZERO, nullptr); 7715 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCompressedTexImage2D error"); 7716 destroyGLES(&eglWindow); 7717 napi_value result = nullptr; 7718 napi_create_int32(env, FAILED, &result); 7719 return result; 7720} 7721 7722static napi_value GLCompressedTexImage3DAbnormal(napi_env env, napi_callback_info info) 7723{ 7724 (void)info; 7725 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7726 initGLES(&eglWindow); 7727 glCompressedTexImage3D(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ONE, GL_ZERO, nullptr); 7728 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCompressedTexImage3D error"); 7729 destroyGLES(&eglWindow); 7730 napi_value result = nullptr; 7731 napi_create_int32(env, FAILED, &result); 7732 return result; 7733} 7734 7735static napi_value GLCompressedTexSubImage2DAbnormal(napi_env env, napi_callback_info info) 7736{ 7737 (void)info; 7738 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7739 initGLES(&eglWindow); 7740 glCompressedTexSubImage2D(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, nullptr); 7741 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCompressedTexSubImage2D error"); 7742 destroyGLES(&eglWindow); 7743 napi_value result = nullptr; 7744 napi_create_int32(env, FAILED, &result); 7745 return result; 7746} 7747 7748static napi_value GLCompressedTexSubImage3DAbnormal(napi_env env, napi_callback_info info) 7749{ 7750 (void)info; 7751 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7752 initGLES(&eglWindow); 7753 glCompressedTexSubImage3D(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, 7754 nullptr); 7755 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCompressedTexSubImage3D error"); 7756 destroyGLES(&eglWindow); 7757 napi_value result = nullptr; 7758 napi_create_int32(env, FAILED, &result); 7759 return result; 7760} 7761 7762static napi_value GLCopyTexSubImage3DAbnormal(napi_env env, napi_callback_info info) 7763{ 7764 (void)info; 7765 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7766 initGLES(&eglWindow); 7767 glCopyTexSubImage3D(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO); 7768 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glCopyTexSubImage3D error"); 7769 destroyGLES(&eglWindow); 7770 napi_value result = nullptr; 7771 napi_create_int32(env, FAILED, &result); 7772 return result; 7773} 7774 7775static napi_value GLDrawElementsAbnormal(napi_env env, napi_callback_info info) 7776{ 7777 (void)info; 7778 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7779 initGLES(&eglWindow); 7780 glDrawElements(GL_ZERO, FAILED, GL_ZERO, nullptr); 7781 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawElements error"); 7782 destroyGLES(&eglWindow); 7783 napi_value result = nullptr; 7784 napi_create_int32(env, FAILED, &result); 7785 return result; 7786} 7787 7788static napi_value GLDrawElementsBaseVertexAbnormal(napi_env env, napi_callback_info info) 7789{ 7790 (void)info; 7791 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7792 initGLES(&eglWindow); 7793 glDrawElementsBaseVertex(GL_ZERO, GL_ZERO, GL_ZERO, nullptr, GL_ZERO); 7794 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawElementsBaseVertex error"); 7795 destroyGLES(&eglWindow); 7796 napi_value result = nullptr; 7797 napi_create_int32(env, FAILED, &result); 7798 return result; 7799} 7800 7801static napi_value GLDrawElementsIndirectAbnormal(napi_env env, napi_callback_info info) 7802{ 7803 (void)info; 7804 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7805 initGLES(&eglWindow); 7806 glDrawElementsIndirect(GL_ZERO, GL_ZERO, nullptr); 7807 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawElementsIndirect error"); 7808 destroyGLES(&eglWindow); 7809 napi_value result = nullptr; 7810 napi_create_int32(env, FAILED, &result); 7811 return result; 7812} 7813 7814static napi_value GLDrawElementsInstancedAbnormal(napi_env env, napi_callback_info info) 7815{ 7816 (void)info; 7817 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7818 initGLES(&eglWindow); 7819 glDrawElementsInstanced(GL_ZERO, FAILED, GL_ZERO, nullptr, FAILED); 7820 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawElementsInstanced error"); 7821 destroyGLES(&eglWindow); 7822 napi_value result = nullptr; 7823 napi_create_int32(env, FAILED, &result); 7824 return result; 7825} 7826 7827static napi_value GLDrawElementsInstancedBaseVertexAbnormal(napi_env env, napi_callback_info info) 7828{ 7829 (void)info; 7830 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7831 initGLES(&eglWindow); 7832 glDrawElementsInstancedBaseVertex(FAILED, GL_ONE, GL_UNSIGNED_BYTE, nullptr, GL_ONE, GL_ONE); 7833 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawElementsInstancedBaseVertex error"); 7834 destroyGLES(&eglWindow); 7835 napi_value result = nullptr; 7836 napi_create_int32(env, FAILED, &result); 7837 return result; 7838} 7839 7840static napi_value GLDrawRangeElementsAbnormal(napi_env env, napi_callback_info info) 7841{ 7842 (void)info; 7843 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7844 initGLES(&eglWindow); 7845 glDrawRangeElements(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, nullptr); 7846 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawRangeElements error"); 7847 destroyGLES(&eglWindow); 7848 napi_value result = nullptr; 7849 napi_create_int32(env, FAILED, &result); 7850 return result; 7851} 7852 7853static napi_value GLDrawRangeElementsBaseVertexAbnormal(napi_env env, napi_callback_info info) 7854{ 7855 (void)info; 7856 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7857 initGLES(&eglWindow); 7858 glDrawRangeElementsBaseVertex(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO, nullptr, GL_ZERO); 7859 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glDrawRangeElementsBaseVertex error"); 7860 destroyGLES(&eglWindow); 7861 napi_value result = nullptr; 7862 napi_create_int32(env, FAILED, &result); 7863 return result; 7864} 7865 7866static napi_value GLEnableAbnormal(napi_env env, napi_callback_info info) 7867{ 7868 (void)info; 7869 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7870 initGLES(&eglWindow); 7871 glEnable(GL_ZERO); 7872 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glEnable error"); 7873 destroyGLES(&eglWindow); 7874 napi_value result = nullptr; 7875 napi_create_int32(env, FAILED, &result); 7876 return result; 7877} 7878 7879static napi_value GLEnableiAbnormal(napi_env env, napi_callback_info info) 7880{ 7881 (void)info; 7882 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7883 initGLES(&eglWindow); 7884 glEnablei(GL_ZERO, GL_ZERO); 7885 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glEnablei error"); 7886 destroyGLES(&eglWindow); 7887 napi_value result = nullptr; 7888 napi_create_int32(env, FAILED, &result); 7889 return result; 7890} 7891 7892static napi_value GLEnableVertexAttribArrayAbnormal(napi_env env, napi_callback_info info) 7893{ 7894 (void)info; 7895 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7896 initGLES(&eglWindow); 7897 glEnableVertexAttribArray(GL_MAX_VERTEX_ATTRIBS); 7898 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glEnableVertexAttribArray error"); 7899 destroyGLES(&eglWindow); 7900 napi_value result = nullptr; 7901 napi_create_int32(env, FAILED, &result); 7902 return result; 7903} 7904 7905static napi_value GLEndQueryAbnormal(napi_env env, napi_callback_info info) 7906{ 7907 (void)info; 7908 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7909 initGLES(&eglWindow); 7910 glEndQuery(GL_ZERO); 7911 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glEndQuery error"); 7912 destroyGLES(&eglWindow); 7913 napi_value result = nullptr; 7914 napi_create_int32(env, FAILED, &result); 7915 return result; 7916} 7917 7918static napi_value GLEndTransformFeedbackAbnormal(napi_env env, napi_callback_info info) 7919{ 7920 (void)info; 7921 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7922 initGLES(&eglWindow); 7923 glEndTransformFeedback(); 7924 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glEndTransformFeedback error"); 7925 destroyGLES(&eglWindow); 7926 napi_value result = nullptr; 7927 napi_create_int32(env, FAILED, &result); 7928 return result; 7929} 7930 7931static napi_value GLFenceSyncAbnormal(napi_env env, napi_callback_info info) 7932{ 7933 (void)info; 7934 EGLWindow eglWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT}; 7935 initGLES(&eglWindow); 7936 glFenceSync(GL_ZERO, GL_ONE); 7937 NAPI_ASSERT(env, glGetError() != GL_NO_ERROR, "glFenceSync error"); 7938 destroyGLES(&eglWindow); 7939 napi_value result = nullptr; 7940 napi_create_int32(env, FAILED, &result); 7941 return result; 7942} 7943 7944EXTERN_C_START 7945static napi_value Init(napi_env env, napi_value exports) 7946{ 7947 napi_property_descriptor desc[] = { 7948 {"gLActiveShaderProgram", nullptr, GLActiveShaderProgram, nullptr, nullptr, nullptr, napi_default, nullptr}, 7949 {"gLActiveTexture", nullptr, GLActiveTexture, nullptr, nullptr, nullptr, napi_default, nullptr}, 7950 {"gLAttachShader", nullptr, GLAttachShader, nullptr, nullptr, nullptr, napi_default, nullptr}, 7951 {"gLBeginQuery", nullptr, GLBeginQuery, nullptr, nullptr, nullptr, napi_default, nullptr}, 7952 {"gLBeginTransformFeedback", nullptr, GLBeginTransformFeedback, nullptr, nullptr, nullptr, napi_default, 7953 nullptr}, 7954 {"gLBindAttribLocation", nullptr, GLBindAttribLocation, nullptr, nullptr, nullptr, napi_default, nullptr}, 7955 {"gLBindBuffer", nullptr, GLBindBuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 7956 {"gLBindBufferBase", nullptr, GLBindBufferBase, nullptr, nullptr, nullptr, napi_default, nullptr}, 7957 {"gLBindBufferRange", nullptr, GLBindBufferRange, nullptr, nullptr, nullptr, napi_default, nullptr}, 7958 {"gLBindFramebuffer", nullptr, GLBindFramebuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 7959 {"gLBindImageTexture", nullptr, GLBindImageTexture, nullptr, nullptr, nullptr, napi_default, nullptr}, 7960 {"gLBindProgramPipeline", nullptr, GLBindProgramPipeline, nullptr, nullptr, nullptr, napi_default, nullptr}, 7961 {"gLBindRenderbuffer", nullptr, GLBindRenderbuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 7962 {"gLBindSampler", nullptr, GLBindSampler, nullptr, nullptr, nullptr, napi_default, nullptr}, 7963 {"gLBindTexture", nullptr, GLBindTexture, nullptr, nullptr, nullptr, napi_default, nullptr}, 7964 {"gLBindTransformFeedback", nullptr, GLBindTransformFeedback, nullptr, nullptr, nullptr, napi_default, nullptr}, 7965 {"gLBindVertexArray", nullptr, GLBindVertexArray, nullptr, nullptr, nullptr, napi_default, nullptr}, 7966 {"gLBindVertexBuffer", nullptr, GLBindVertexBuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 7967 {"gLBlendBarrier", nullptr, GLBlendBarrier, nullptr, nullptr, nullptr, napi_default, nullptr}, 7968 {"gLBlendColor", nullptr, GLBlendColor, nullptr, nullptr, nullptr, napi_default, nullptr}, 7969 {"gLBlendEquation", nullptr, GLBlendEquation, nullptr, nullptr, nullptr, napi_default, nullptr}, 7970 {"gLBlendEquationi", nullptr, GLBlendEquationi, nullptr, nullptr, nullptr, napi_default, nullptr}, 7971 {"gLBlendEquationSeparate", nullptr, GLBlendEquationSeparate, nullptr, nullptr, nullptr, napi_default, nullptr}, 7972 {"gLBlendEquationSeparatei", nullptr, GLBlendEquationSeparatei, nullptr, nullptr, nullptr, napi_default, 7973 nullptr}, 7974 {"gLBlendFunc", nullptr, GLBlendFunc, nullptr, nullptr, nullptr, napi_default, nullptr}, 7975 {"gLBlendFunci", nullptr, GLBlendFunci, nullptr, nullptr, nullptr, napi_default, nullptr}, 7976 {"gLBlendFuncSeparate", nullptr, GLBlendFuncSeparate, nullptr, nullptr, nullptr, napi_default, nullptr}, 7977 {"gLBlendFuncSeparatei", nullptr, GLBlendFuncSeparatei, nullptr, nullptr, nullptr, napi_default, nullptr}, 7978 {"gLBlitFramebuffer", nullptr, GLBlitFramebuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 7979 {"gLBufferData", nullptr, GLBufferData, nullptr, nullptr, nullptr, napi_default, nullptr}, 7980 {"gLBufferSubData", nullptr, GLBufferSubData, nullptr, nullptr, nullptr, napi_default, nullptr}, 7981 {"gLCheckFramebufferStatus", nullptr, GLCheckFramebufferStatus, nullptr, nullptr, nullptr, napi_default, 7982 nullptr}, 7983 {"gLClear", nullptr, GLClear, nullptr, nullptr, nullptr, napi_default, nullptr}, 7984 {"gLClearBufferfi", nullptr, GLClearBufferfi, nullptr, nullptr, nullptr, napi_default, nullptr}, 7985 {"gLClearBufferfv", nullptr, GLClearBufferfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 7986 {"gLClearBufferiv", nullptr, GLClearBufferiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 7987 {"gLClearBufferuiv", nullptr, GLClearBufferuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 7988 {"gLClearColor", nullptr, GLClearColor, nullptr, nullptr, nullptr, napi_default, nullptr}, 7989 {"gLClearDepthf", nullptr, GLClearDepthf, nullptr, nullptr, nullptr, napi_default, nullptr}, 7990 {"gLClearStencil", nullptr, GLClearStencil, nullptr, nullptr, nullptr, napi_default, nullptr}, 7991 {"gLClientWaitSync", nullptr, GLClientWaitSync, nullptr, nullptr, nullptr, napi_default, nullptr}, 7992 {"gLColorMask", nullptr, GLColorMask, nullptr, nullptr, nullptr, napi_default, nullptr}, 7993 {"gLColorMaski", nullptr, GLColorMaski, nullptr, nullptr, nullptr, napi_default, nullptr}, 7994 {"gLCompileShader", nullptr, GLCompileShader, nullptr, nullptr, nullptr, napi_default, nullptr}, 7995 {"gLCompressedTexImage2D", nullptr, GLCompressedTexImage2D, nullptr, nullptr, nullptr, napi_default, nullptr}, 7996 {"gLCompressedTexImage3D", nullptr, GLCompressedTexImage3D, nullptr, nullptr, nullptr, napi_default, nullptr}, 7997 {"gLCompressedTexSubImage2D", nullptr, GLCompressedTexSubImage2D, nullptr, nullptr, nullptr, napi_default, 7998 nullptr}, 7999 {"gLCompressedTexSubImage3D", nullptr, GLCompressedTexSubImage3D, nullptr, nullptr, nullptr, napi_default, 8000 nullptr}, 8001 {"gLCopyBufferSubData", nullptr, GLCopyBufferSubData, nullptr, nullptr, nullptr, napi_default, nullptr}, 8002 {"gLCopyImageSubData", nullptr, GLCopyImageSubData, nullptr, nullptr, nullptr, napi_default, nullptr}, 8003 {"gLCopyTexImage2D", nullptr, GLCopyTexImage2D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8004 {"gLCopyTexSubImage2D", nullptr, GLCopyTexSubImage2D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8005 {"gLCopyTexSubImage3D", nullptr, GLCopyTexSubImage3D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8006 {"gLCreateProgram", nullptr, GLCreateProgram, nullptr, nullptr, nullptr, napi_default, nullptr}, 8007 {"gLCreateShader", nullptr, GLCreateShader, nullptr, nullptr, nullptr, napi_default, nullptr}, 8008 {"gLCreateShaderProgramv", nullptr, GLCreateShaderProgramv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8009 {"gLCullFace", nullptr, GLCullFace, nullptr, nullptr, nullptr, napi_default, nullptr}, 8010 {"gLDebugMessageCallback", nullptr, GLDebugMessageCallback, nullptr, nullptr, nullptr, napi_default, nullptr}, 8011 {"gLDebugMessageControl", nullptr, GLDebugMessageControl, nullptr, nullptr, nullptr, napi_default, nullptr}, 8012 {"gLDebugMessageInsert", nullptr, GLDebugMessageInsert, nullptr, nullptr, nullptr, napi_default, nullptr}, 8013 {"gLDeleteBuffers", nullptr, GLDeleteBuffers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8014 {"gLDeleteFramebuffers", nullptr, GLDeleteFramebuffers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8015 {"gLDeleteProgram", nullptr, GLDeleteProgram, nullptr, nullptr, nullptr, napi_default, nullptr}, 8016 {"gLDeleteProgramPipelines", nullptr, GLDeleteProgramPipelines, nullptr, nullptr, nullptr, napi_default, 8017 nullptr}, 8018 {"gLDeleteQueries", nullptr, GLDeleteQueries, nullptr, nullptr, nullptr, napi_default, nullptr}, 8019 {"gLDeleteRenderbuffers", nullptr, GLDeleteRenderbuffers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8020 {"gLDeleteSamplers", nullptr, GLDeleteSamplers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8021 {"gLDeleteShader", nullptr, GLDeleteShader, nullptr, nullptr, nullptr, napi_default, nullptr}, 8022 {"gLDeleteSync", nullptr, GLDeleteSync, nullptr, nullptr, nullptr, napi_default, nullptr}, 8023 {"gLDeleteTextures", nullptr, GLDeleteTextures, nullptr, nullptr, nullptr, napi_default, nullptr}, 8024 {"gLDeleteTransformFeedbacks", nullptr, GLDeleteTransformFeedbacks, nullptr, nullptr, nullptr, napi_default, 8025 nullptr}, 8026 {"gLDeleteVertexArrays", nullptr, GLDeleteVertexArrays, nullptr, nullptr, nullptr, napi_default, nullptr}, 8027 {"gLDepthFunc", nullptr, GLDepthFunc, nullptr, nullptr, nullptr, napi_default, nullptr}, 8028 {"gLDepthMask", nullptr, GLDepthMask, nullptr, nullptr, nullptr, napi_default, nullptr}, 8029 {"gLDepthRangef", nullptr, GLDepthRangef, nullptr, nullptr, nullptr, napi_default, nullptr}, 8030 {"gLDetachShader", nullptr, GLDetachShader, nullptr, nullptr, nullptr, napi_default, nullptr}, 8031 {"gLDisable", nullptr, GLDisable, nullptr, nullptr, nullptr, napi_default, nullptr}, 8032 {"gLDisablei", nullptr, GLDisablei, nullptr, nullptr, nullptr, napi_default, nullptr}, 8033 {"gLDisableVertexAttribArray", nullptr, GLDisableVertexAttribArray, nullptr, nullptr, nullptr, napi_default, 8034 nullptr}, 8035 {"gLDispatchCompute", nullptr, GLDispatchCompute, nullptr, nullptr, nullptr, napi_default, nullptr}, 8036 {"gLDispatchComputeIndirect", nullptr, GLDispatchComputeIndirect, nullptr, nullptr, nullptr, napi_default, 8037 nullptr}, 8038 {"gLDrawArrays", nullptr, GLDrawArrays, nullptr, nullptr, nullptr, napi_default, nullptr}, 8039 {"gLDrawArraysIndirect", nullptr, GLDrawArraysIndirect, nullptr, nullptr, nullptr, napi_default, nullptr}, 8040 {"gLDrawArraysInstanced", nullptr, GLDrawArraysInstanced, nullptr, nullptr, nullptr, napi_default, nullptr}, 8041 {"gLDrawBuffers", nullptr, GLDrawBuffers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8042 {"gLDrawElements", nullptr, GLDrawElements, nullptr, nullptr, nullptr, napi_default, nullptr}, 8043 {"gLDrawElementsBaseVertex", nullptr, GLDrawElementsBaseVertex, nullptr, nullptr, nullptr, napi_default, 8044 nullptr}, 8045 {"gLDrawElementsIndirect", nullptr, GLDrawElementsIndirect, nullptr, nullptr, nullptr, napi_default, nullptr}, 8046 {"gLDrawElementsInstanced", nullptr, GLDrawElementsInstanced, nullptr, nullptr, nullptr, napi_default, nullptr}, 8047 {"gLDrawElementsInstancedBaseVertex", nullptr, GLDrawElementsInstancedBaseVertex, nullptr, nullptr, nullptr, 8048 napi_default, nullptr}, 8049 {"gLDrawRangeElements", nullptr, GLDrawRangeElements, nullptr, nullptr, nullptr, napi_default, nullptr}, 8050 {"gLDrawRangeElementsBaseVertex", nullptr, GLDrawRangeElementsBaseVertex, nullptr, nullptr, nullptr, 8051 napi_default, nullptr}, 8052 {"gLEnable", nullptr, GLEnable, nullptr, nullptr, nullptr, napi_default, nullptr}, 8053 {"gLEnablei", nullptr, GLEnablei, nullptr, nullptr, nullptr, napi_default, nullptr}, 8054 {"gLEnableVertexAttribArray", nullptr, GLEnableVertexAttribArray, nullptr, nullptr, nullptr, napi_default, 8055 nullptr}, 8056 {"gLEndQuery", nullptr, GLEndQuery, nullptr, nullptr, nullptr, napi_default, nullptr}, 8057 {"gLEndTransformFeedback", nullptr, GLEndTransformFeedback, nullptr, nullptr, nullptr, napi_default, nullptr}, 8058 {"gLFenceSync", nullptr, GLFenceSync, nullptr, nullptr, nullptr, napi_default, nullptr}, 8059 {"gLFinish", nullptr, GLFinish, nullptr, nullptr, nullptr, napi_default, nullptr}, 8060 {"gLFlush", nullptr, GLFlush, nullptr, nullptr, nullptr, napi_default, nullptr}, 8061 {"gLFlushMappedBufferRange", nullptr, GLFlushMappedBufferRange, nullptr, nullptr, nullptr, napi_default, 8062 nullptr}, 8063 {"gLFramebufferParameteri", nullptr, GLFramebufferParameteri, nullptr, nullptr, nullptr, napi_default, nullptr}, 8064 {"gLFramebufferRenderbuffer", nullptr, GLFramebufferRenderbuffer, nullptr, nullptr, nullptr, napi_default, 8065 nullptr}, 8066 {"gLFramebufferTexture", nullptr, GLFramebufferTexture, nullptr, nullptr, nullptr, napi_default, nullptr}, 8067 {"gLFramebufferTexture2D", nullptr, GLFramebufferTexture2D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8068 {"gLFramebufferTextureLayer", nullptr, GLFramebufferTextureLayer, nullptr, nullptr, nullptr, napi_default, 8069 nullptr}, 8070 {"gLFrontFace", nullptr, GLFrontFace, nullptr, nullptr, nullptr, napi_default, nullptr}, 8071 {"gLGenBuffers", nullptr, GLGenBuffers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8072 {"gLGenerateMipmap", nullptr, GLGenerateMipmap, nullptr, nullptr, nullptr, napi_default, nullptr}, 8073 {"gLGenFramebuffers", nullptr, GLGenFramebuffers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8074 {"gLGenProgramPipelines", nullptr, GLGenProgramPipelines, nullptr, nullptr, nullptr, napi_default, nullptr}, 8075 {"gLGenQueries", nullptr, GLGenQueries, nullptr, nullptr, nullptr, napi_default, nullptr}, 8076 {"gLGenRenderbuffers", nullptr, GLGenRenderbuffers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8077 {"gLGenSamplers", nullptr, GLGenSamplers, nullptr, nullptr, nullptr, napi_default, nullptr}, 8078 {"gLGenTextures", nullptr, GLGenTextures, nullptr, nullptr, nullptr, napi_default, nullptr}, 8079 {"gLGenTransformFeedbacks", nullptr, GLGenTransformFeedbacks, nullptr, nullptr, nullptr, napi_default, nullptr}, 8080 {"gLGenVertexArrays", nullptr, GLGenVertexArrays, nullptr, nullptr, nullptr, napi_default, nullptr}, 8081 {"gLGetActiveAttrib", nullptr, GLGetActiveAttrib, nullptr, nullptr, nullptr, napi_default, nullptr}, 8082 {"gLGetActiveUniform", nullptr, GLGetActiveUniform, nullptr, nullptr, nullptr, napi_default, nullptr}, 8083 {"gLGetActiveUniformBlockiv", nullptr, GLGetActiveUniformBlockiv, nullptr, nullptr, nullptr, napi_default, 8084 nullptr}, 8085 {"gLGetActiveUniformBlockName", nullptr, GLGetActiveUniformBlockName, nullptr, nullptr, nullptr, napi_default, 8086 nullptr}, 8087 {"gLGetActiveUniformsiv", nullptr, GLGetActiveUniformsiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8088 {"gLGetAttachedShaders", nullptr, GLGetAttachedShaders, nullptr, nullptr, nullptr, napi_default, nullptr}, 8089 {"gLGetAttribLocation", nullptr, GLGetAttribLocation, nullptr, nullptr, nullptr, napi_default, nullptr}, 8090 {"gLGetBooleani_v", nullptr, GLGetBooleani_v, nullptr, nullptr, nullptr, napi_default, nullptr}, 8091 {"gLGetBooleanv", nullptr, GLGetBooleanv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8092 {"gLGetBufferParameteri64v", nullptr, GLGetBufferParameteri64v, nullptr, nullptr, nullptr, napi_default, 8093 nullptr}, 8094 {"gLGetBufferParameteriv", nullptr, GLGetBufferParameteriv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8095 {"gLGetBufferPointerv", nullptr, GLGetBufferPointerv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8096 {"gLGetDebugMessageLog", nullptr, GLGetDebugMessageLog, nullptr, nullptr, nullptr, napi_default, nullptr}, 8097 {"gLGetError", nullptr, GLGetError, nullptr, nullptr, nullptr, napi_default, nullptr}, 8098 {"gLGetFloatv", nullptr, GLGetFloatv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8099 {"gLGetFragDataLocation", nullptr, GLGetFragDataLocation, nullptr, nullptr, nullptr, napi_default, nullptr}, 8100 {"gLGetFramebufferAttachmentParameteriv", nullptr, GLGetFramebufferAttachmentParameteriv, nullptr, nullptr, 8101 nullptr, napi_default, nullptr}, 8102 {"gLGetFramebufferParameteriv", nullptr, GLGetFramebufferParameteriv, nullptr, nullptr, nullptr, napi_default, 8103 nullptr}, 8104 {"gLGetGraphicsResetStatus", nullptr, GLGetGraphicsResetStatus, nullptr, nullptr, nullptr, napi_default, 8105 nullptr}, 8106 {"gLGetInteger64i_v", nullptr, GLGetInteger64i_v, nullptr, nullptr, nullptr, napi_default, nullptr}, 8107 {"gLGetInteger64v", nullptr, GLGetInteger64v, nullptr, nullptr, nullptr, napi_default, nullptr}, 8108 {"gLGetIntegeri_v", nullptr, GLGetIntegeri_v, nullptr, nullptr, nullptr, napi_default, nullptr}, 8109 {"gLGetIntegerv", nullptr, GLGetIntegerv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8110 {"gLGetInternalformativ", nullptr, GLGetInternalformativ, nullptr, nullptr, nullptr, napi_default, nullptr}, 8111 {"gLGetMultisamplefv", nullptr, GLGetMultisamplefv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8112 {"gLGetnUniformfv", nullptr, GLGetnUniformfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8113 {"gLGetnUniformiv", nullptr, GLGetnUniformiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8114 {"gLGetnUniformuiv", nullptr, GLGetnUniformuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8115 {"gLGetObjectLabel", nullptr, GLGetObjectLabel, nullptr, nullptr, nullptr, napi_default, nullptr}, 8116 {"gLGetObjectPtrLabel", nullptr, GLGetObjectPtrLabel, nullptr, nullptr, nullptr, napi_default, nullptr}, 8117 {"gLGetPointerv", nullptr, GLGetPointerv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8118 {"gLGetProgramBinary", nullptr, GLGetProgramBinary, nullptr, nullptr, nullptr, napi_default, nullptr}, 8119 {"gLGetProgramInfoLog", nullptr, GLGetProgramInfoLog, nullptr, nullptr, nullptr, napi_default, nullptr}, 8120 {"gLGetProgramInterfaceiv", nullptr, GLGetProgramInterfaceiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8121 {"gLGetProgramiv", nullptr, GLGetProgramiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8122 {"gLGetProgramPipelineInfoLog", nullptr, GLGetProgramPipelineInfoLog, nullptr, nullptr, nullptr, napi_default, 8123 nullptr}, 8124 {"gLGetProgramPipelineiv", nullptr, GLGetProgramPipelineiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8125 {"gLGetProgramResourceIndex", nullptr, GLGetProgramResourceIndex, nullptr, nullptr, nullptr, napi_default, 8126 nullptr}, 8127 {"gLGetProgramResourceiv", nullptr, GLGetProgramResourceiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8128 {"gLGetProgramResourceLocation", nullptr, GLGetProgramResourceLocation, nullptr, nullptr, nullptr, napi_default, 8129 nullptr}, 8130 {"gLGetProgramResourceName", nullptr, GLGetProgramResourceName, nullptr, nullptr, nullptr, napi_default, 8131 nullptr}, 8132 {"gLGetQueryiv", nullptr, GLGetQueryiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8133 {"gLGetQueryObjectuiv", nullptr, GLGetQueryObjectuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8134 {"gLGetRenderbufferParameteriv", nullptr, GLGetRenderbufferParameteriv, nullptr, nullptr, nullptr, napi_default, 8135 nullptr}, 8136 {"gLGetSamplerParameterfv", nullptr, GLGetSamplerParameterfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8137 {"gLGetSamplerParameterIiv", nullptr, GLGetSamplerParameterIiv, nullptr, nullptr, nullptr, napi_default, 8138 nullptr}, 8139 {"gLGetSamplerParameterIuiv", nullptr, GLGetSamplerParameterIuiv, nullptr, nullptr, nullptr, napi_default, 8140 nullptr}, 8141 {"gLGetSamplerParameteriv", nullptr, GLGetSamplerParameteriv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8142 8143 {"gLGetShaderInfoLog", nullptr, GLGetShaderInfoLog, nullptr, nullptr, nullptr, napi_default, nullptr}, 8144 {"gLGetShaderiv", nullptr, GLGetShaderiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8145 {"gLGetShaderPrecisionFormat", nullptr, GLGetShaderPrecisionFormat, nullptr, nullptr, nullptr, napi_default, 8146 nullptr}, 8147 {"gLGetShaderSource", nullptr, GLGetShaderSource, nullptr, nullptr, nullptr, napi_default, nullptr}, 8148 {"gLGetString", nullptr, GLGetString, nullptr, nullptr, nullptr, napi_default, nullptr}, 8149 {"gLGetStringi", nullptr, GLGetStringi, nullptr, nullptr, nullptr, napi_default, nullptr}, 8150 {"gLGetSynciv", nullptr, GLGetSynciv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8151 {"gLGetTexLevelParameterfv", nullptr, GLGetTexLevelParameterfv, nullptr, nullptr, nullptr, napi_default, 8152 nullptr}, 8153 {"gLGetTexLevelParameteriv", nullptr, GLGetTexLevelParameteriv, nullptr, nullptr, nullptr, napi_default, 8154 nullptr}, 8155 {"gLGetTexParameterfv", nullptr, GLGetTexParameterfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8156 {"gLGetTexParameterIiv", nullptr, GLGetTexParameterIiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8157 {"gLGetTexParameterIuiv", nullptr, GLGetTexParameterIuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8158 {"gLGetTexParameteriv", nullptr, GLGetTexParameteriv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8159 {"gLGetTransformFeedbackVarying", nullptr, GLGetTransformFeedbackVarying, nullptr, nullptr, nullptr, 8160 napi_default, nullptr}, 8161 {"gLGetUniformBlockIndex", nullptr, GLGetUniformBlockIndex, nullptr, nullptr, nullptr, napi_default, nullptr}, 8162 {"gLGetUniformfv", nullptr, GLGetUniformfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8163 {"gLGetUniformIndices", nullptr, GLGetUniformIndices, nullptr, nullptr, nullptr, napi_default, nullptr}, 8164 {"gLGetUniformiv", nullptr, GLGetUniformiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8165 {"gLGetUniformLocation", nullptr, GLGetUniformLocation, nullptr, nullptr, nullptr, napi_default, nullptr}, 8166 {"gLGetUniformuiv", nullptr, GLGetUniformuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8167 {"gLGetVertexAttribfv", nullptr, GLGetVertexAttribfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8168 {"gLGetVertexAttribIiv", nullptr, GLGetVertexAttribIiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8169 {"gLGetVertexAttribIuiv", nullptr, GLGetVertexAttribIuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8170 {"gLGetVertexAttribiv", nullptr, GLGetVertexAttribiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8171 {"gLGetVertexAttribPointerv", nullptr, GLGetVertexAttribPointerv, nullptr, nullptr, nullptr, napi_default, 8172 nullptr}, 8173 {"gLHint", nullptr, GLHint, nullptr, nullptr, nullptr, napi_default, nullptr}, 8174 {"gLInvalidateFramebuffer", nullptr, GLInvalidateFramebuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8175 {"gLInvalidateSubFramebuffer", nullptr, GLInvalidateSubFramebuffer, nullptr, nullptr, nullptr, napi_default, 8176 nullptr}, 8177 {"gLIsBuffer", nullptr, GLIsBuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8178 {"gLIsEnabled", nullptr, GLIsEnabled, nullptr, nullptr, nullptr, napi_default, nullptr}, 8179 {"gLIsEnabledi", nullptr, GLIsEnabledi, nullptr, nullptr, nullptr, napi_default, nullptr}, 8180 {"gLIsFramebuffer", nullptr, GLIsFramebuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8181 {"gLIsProgram", nullptr, GLIsProgram, nullptr, nullptr, nullptr, napi_default, nullptr}, 8182 {"gLIsProgramPipeline", nullptr, GLIsProgramPipeline, nullptr, nullptr, nullptr, napi_default, nullptr}, 8183 {"gLIsQuery", nullptr, GLIsQuery, nullptr, nullptr, nullptr, napi_default, nullptr}, 8184 {"gLIsRenderbuffer", nullptr, GLIsRenderbuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8185 {"gLIsSampler", nullptr, GLIsSampler, nullptr, nullptr, nullptr, napi_default, nullptr}, 8186 {"gLIsShader", nullptr, GLIsShader, nullptr, nullptr, nullptr, napi_default, nullptr}, 8187 {"gLIsSync", nullptr, GLIsSync, nullptr, nullptr, nullptr, napi_default, nullptr}, 8188 {"gLIsTexture", nullptr, GLIsTexture, nullptr, nullptr, nullptr, napi_default, nullptr}, 8189 {"gLIsTransformFeedback", nullptr, GLIsTransformFeedback, nullptr, nullptr, nullptr, napi_default, nullptr}, 8190 {"gLIsVertexArray", nullptr, GLIsVertexArray, nullptr, nullptr, nullptr, napi_default, nullptr}, 8191 {"gLLineWidth", nullptr, GLLineWidth, nullptr, nullptr, nullptr, napi_default, nullptr}, 8192 {"gLLinkProgram", nullptr, GLLinkProgram, nullptr, nullptr, nullptr, napi_default, nullptr}, 8193 {"gLMapBufferRange", nullptr, GLMapBufferRange, nullptr, nullptr, nullptr, napi_default, nullptr}, 8194 {"gLMemoryBarrier", nullptr, GLMemoryBarrier, nullptr, nullptr, nullptr, napi_default, nullptr}, 8195 {"gLMemoryBarrierByRegion", nullptr, GLMemoryBarrierByRegion, nullptr, nullptr, nullptr, napi_default, nullptr}, 8196 {"gLMinSampleShading", nullptr, GLMinSampleShading, nullptr, nullptr, nullptr, napi_default, nullptr}, 8197 {"gLObjectLabel", nullptr, GLObjectLabel, nullptr, nullptr, nullptr, napi_default, nullptr}, 8198 {"gLObjectPtrLabel", nullptr, GLObjectPtrLabel, nullptr, nullptr, nullptr, napi_default, nullptr}, 8199 {"gLPatchParameteri", nullptr, GLPatchParameteri, nullptr, nullptr, nullptr, napi_default, nullptr}, 8200 {"gLPauseTransformFeedback", nullptr, GLPauseTransformFeedback, nullptr, nullptr, nullptr, napi_default, 8201 nullptr}, 8202 {"gLPixelStorei", nullptr, GLPixelStorei, nullptr, nullptr, nullptr, napi_default, nullptr}, 8203 {"gLPolygonOffset", nullptr, GLPolygonOffset, nullptr, nullptr, nullptr, napi_default, nullptr}, 8204 {"gLPopDebugGroup", nullptr, GLPopDebugGroup, nullptr, nullptr, nullptr, napi_default, nullptr}, 8205 8206 {"gLPrimitiveBoundingBox", nullptr, GLPrimitiveBoundingBox, nullptr, nullptr, nullptr, napi_default, nullptr}, 8207 {"gLProgramBinary", nullptr, GLProgramBinary, nullptr, nullptr, nullptr, napi_default, nullptr}, 8208 {"gLProgramParameteri", nullptr, GLProgramParameteri, nullptr, nullptr, nullptr, napi_default, nullptr}, 8209 {"gLProgramUniform1f", nullptr, GLProgramUniform1f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8210 {"gLProgramUniform1fv", nullptr, GLProgramUniform1fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8211 {"gLProgramUniform1i", nullptr, GLProgramUniform1i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8212 {"gLProgramUniform1iv", nullptr, GLProgramUniform1iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8213 {"gLProgramUniform1ui", nullptr, GLProgramUniform1ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8214 {"gLProgramUniform1uiv", nullptr, GLProgramUniform1uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8215 {"gLProgramUniform2f", nullptr, GLProgramUniform2f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8216 {"gLProgramUniform2fv", nullptr, GLProgramUniform2fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8217 {"gLProgramUniform2i", nullptr, GLProgramUniform2i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8218 {"gLProgramUniform2iv", nullptr, GLProgramUniform2iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8219 {"gLProgramUniform2ui", nullptr, GLProgramUniform2ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8220 {"gLProgramUniform2uiv", nullptr, GLProgramUniform2uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8221 {"gLProgramUniform3f", nullptr, GLProgramUniform3f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8222 {"gLProgramUniform3fv", nullptr, GLProgramUniform3fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8223 {"gLProgramUniform3i", nullptr, GLProgramUniform3i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8224 {"gLProgramUniform3iv", nullptr, GLProgramUniform3iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8225 {"gLProgramUniform3ui", nullptr, GLProgramUniform3ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8226 {"gLProgramUniform3uiv", nullptr, GLProgramUniform3uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8227 {"gLProgramUniform4f", nullptr, GLProgramUniform4f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8228 {"gLProgramUniform4fv", nullptr, GLProgramUniform4fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8229 {"gLProgramUniform4i", nullptr, GLProgramUniform4i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8230 {"gLProgramUniform4iv", nullptr, GLProgramUniform4iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8231 {"gLProgramUniform4ui", nullptr, GLProgramUniform4ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8232 {"gLProgramUniform4uiv", nullptr, GLProgramUniform4uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8233 {"gLProgramUniformMatrix2fv", nullptr, GLProgramUniformMatrix2fv, nullptr, nullptr, nullptr, napi_default, 8234 nullptr}, 8235 {"gLProgramUniformMatrix2x3fv", nullptr, GLProgramUniformMatrix2x3fv, nullptr, nullptr, nullptr, napi_default, 8236 nullptr}, 8237 {"gLProgramUniformMatrix2x4fv", nullptr, GLProgramUniformMatrix2x4fv, nullptr, nullptr, nullptr, napi_default, 8238 nullptr}, 8239 {"gLProgramUniformMatrix3fv", nullptr, GLProgramUniformMatrix3fv, nullptr, nullptr, nullptr, napi_default, 8240 nullptr}, 8241 {"gLProgramUniformMatrix3x2fv", nullptr, GLProgramUniformMatrix3x2fv, nullptr, nullptr, nullptr, napi_default, 8242 nullptr}, 8243 {"gLProgramUniformMatrix3x4fv", nullptr, GLProgramUniformMatrix3x4fv, nullptr, nullptr, nullptr, napi_default, 8244 nullptr}, 8245 {"gLProgramUniformMatrix4fv", nullptr, GLProgramUniformMatrix4fv, nullptr, nullptr, nullptr, napi_default, 8246 nullptr}, 8247 {"gLProgramUniformMatrix4x2fv", nullptr, GLProgramUniformMatrix4x2fv, nullptr, nullptr, nullptr, napi_default, 8248 nullptr}, 8249 {"gLProgramUniformMatrix4x3fv", nullptr, GLProgramUniformMatrix4x3fv, nullptr, nullptr, nullptr, napi_default, 8250 nullptr}, 8251 {"gLPushDebugGroup", nullptr, GLPushDebugGroup, nullptr, nullptr, nullptr, napi_default, nullptr}, 8252 {"gLReadBuffer", nullptr, GLReadBuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8253 {"gLReadnPixels", nullptr, GLReadnPixels, nullptr, nullptr, nullptr, napi_default, nullptr}, 8254 {"gLReadPixels", nullptr, GLReadPixels, nullptr, nullptr, nullptr, napi_default, nullptr}, 8255 {"gLReleaseShaderCompiler", nullptr, GLReleaseShaderCompiler, nullptr, nullptr, nullptr, napi_default, nullptr}, 8256 {"gLRenderbufferStorage", nullptr, GLRenderbufferStorage, nullptr, nullptr, nullptr, napi_default, nullptr}, 8257 {"gLRenderbufferStorageMultisample", nullptr, GLRenderbufferStorageMultisample, nullptr, nullptr, nullptr, 8258 napi_default, nullptr}, 8259 {"gLResumeTransformFeedback", nullptr, GLResumeTransformFeedback, nullptr, nullptr, nullptr, napi_default, 8260 nullptr}, 8261 {"gLSampleCoverage", nullptr, GLSampleCoverage, nullptr, nullptr, nullptr, napi_default, nullptr}, 8262 {"gLSampleMaski", nullptr, GLSampleMaski, nullptr, nullptr, nullptr, napi_default, nullptr}, 8263 {"gLSamplerParameterf", nullptr, GLSamplerParameterf, nullptr, nullptr, nullptr, napi_default, nullptr}, 8264 {"gLSamplerParameterfv", nullptr, GLSamplerParameterfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8265 {"gLSamplerParameteri", nullptr, GLSamplerParameteri, nullptr, nullptr, nullptr, napi_default, nullptr}, 8266 {"gLSamplerParameterIiv", nullptr, GLSamplerParameterIiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8267 {"gLSamplerParameterIuiv", nullptr, GLSamplerParameterIuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8268 {"gLSamplerParameteriv", nullptr, GLSamplerParameteriv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8269 {"gLScissor", nullptr, GLScissor, nullptr, nullptr, nullptr, napi_default, nullptr}, 8270 {"gLShaderBinary", nullptr, GLShaderBinary, nullptr, nullptr, nullptr, napi_default, nullptr}, 8271 {"gLShaderSource", nullptr, GLShaderSource, nullptr, nullptr, nullptr, napi_default, nullptr}, 8272 {"gLStencilFunc", nullptr, GLStencilFunc, nullptr, nullptr, nullptr, napi_default, nullptr}, 8273 {"gLStencilFuncSeparate", nullptr, GLStencilFuncSeparate, nullptr, nullptr, nullptr, napi_default, nullptr}, 8274 {"gLStencilMask", nullptr, GLStencilMask, nullptr, nullptr, nullptr, napi_default, nullptr}, 8275 {"gLStencilMaskSeparate", nullptr, GLStencilMaskSeparate, nullptr, nullptr, nullptr, napi_default, nullptr}, 8276 {"gLStencilOp", nullptr, GLStencilOp, nullptr, nullptr, nullptr, napi_default, nullptr}, 8277 {"gLStencilOpSeparate", nullptr, GLStencilOpSeparate, nullptr, nullptr, nullptr, napi_default, nullptr}, 8278 {"gLTexBuffer", nullptr, GLTexBuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8279 {"gLTexBufferRange", nullptr, GLTexBufferRange, nullptr, nullptr, nullptr, napi_default, nullptr}, 8280 {"gLTexImage2D", nullptr, GLTexImage2D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8281 {"gLTexImage3D", nullptr, GLTexImage3D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8282 {"gLTexParameterf", nullptr, GLTexParameterf, nullptr, nullptr, nullptr, napi_default, nullptr}, 8283 {"gLTexParameterfv", nullptr, GLTexParameterfv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8284 {"gLTexParameteri", nullptr, GLTexParameteri, nullptr, nullptr, nullptr, napi_default, nullptr}, 8285 {"gLTexParameterIiv", nullptr, GLTexParameterIiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8286 {"gLTexParameterIuiv", nullptr, GLTexParameterIuiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8287 {"gLTexParameteriv", nullptr, GLTexParameteriv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8288 {"gLTexStorage2D", nullptr, GLTexStorage2D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8289 {"gLTexStorage2DMultisample", nullptr, GLTexStorage2DMultisample, nullptr, nullptr, nullptr, napi_default, 8290 nullptr}, 8291 {"gLTexStorage3D", nullptr, GLTexStorage3D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8292 {"gLTexStorage3DMultisample", nullptr, GLTexStorage3DMultisample, nullptr, nullptr, nullptr, napi_default, 8293 nullptr}, 8294 {"gLTexSubImage2D", nullptr, GLTexSubImage2D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8295 {"gLTexSubImage3D", nullptr, GLTexSubImage3D, nullptr, nullptr, nullptr, napi_default, nullptr}, 8296 {"gLTransformFeedbackVaryings", nullptr, GLTransformFeedbackVaryings, nullptr, nullptr, nullptr, napi_default, 8297 nullptr}, 8298 {"gLUniform1f", nullptr, GLUniform1f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8299 {"gLUniform1fv", nullptr, GLUniform1fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8300 {"gLUniform1i", nullptr, GLUniform1i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8301 {"gLUniform1iv", nullptr, GLUniform1iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8302 {"gLUniform1ui", nullptr, GLUniform1ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8303 {"gLUniform1uiv", nullptr, GLUniform1uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8304 {"gLUniform2f", nullptr, GLUniform2f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8305 {"gLUniform2fv", nullptr, GLUniform2fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8306 {"gLUniform2i", nullptr, GLUniform2i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8307 {"gLUniform2iv", nullptr, GLUniform2iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8308 {"gLUniform2ui", nullptr, GLUniform2ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8309 {"gLUniform2uiv", nullptr, GLUniform2uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8310 {"gLUniform3f", nullptr, GLUniform3f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8311 {"gLUniform3fv", nullptr, GLUniform3fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8312 {"gLUniform3i", nullptr, GLUniform3i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8313 {"gLUniform3iv", nullptr, GLUniform3iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8314 {"gLUniform3ui", nullptr, GLUniform3ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8315 {"gLUniform3uiv", nullptr, GLUniform3uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8316 {"gLUniform4f", nullptr, GLUniform4f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8317 {"gLUniform4fv", nullptr, GLUniform4fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8318 {"gLUniform4i", nullptr, GLUniform4i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8319 {"gLUniform4iv", nullptr, GLUniform4iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8320 {"gLUniform4ui", nullptr, GLUniform4ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8321 {"gLUniform4uiv", nullptr, GLUniform4uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8322 {"gLUniformBlockBinding", nullptr, GLUniformBlockBinding, nullptr, nullptr, nullptr, napi_default, nullptr}, 8323 {"gLUniformMatrix2fv", nullptr, GLUniformMatrix2fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8324 {"gLUniformMatrix2x3fv", nullptr, GLUniformMatrix2x3fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8325 {"gLUniformMatrix2x4fv", nullptr, GLUniformMatrix2x4fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8326 {"gLUniformMatrix3fv", nullptr, GLUniformMatrix3fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8327 {"gLUniformMatrix3x2fv", nullptr, GLUniformMatrix3x2fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8328 {"gLUniformMatrix3x4fv", nullptr, GLUniformMatrix3x4fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8329 {"gLUniformMatrix4fv", nullptr, GLUniformMatrix4fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8330 {"gLUniformMatrix4x2fv", nullptr, GLUniformMatrix4x2fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8331 {"gLUniformMatrix4x3fv", nullptr, GLUniformMatrix4x3fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8332 {"gLUnmapBuffer", nullptr, GLUnmapBuffer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8333 {"gLUseProgram", nullptr, GLUseProgram, nullptr, nullptr, nullptr, napi_default, nullptr}, 8334 {"gLUseProgramStages", nullptr, GLUseProgramStages, nullptr, nullptr, nullptr, napi_default, nullptr}, 8335 {"gLValidateProgram", nullptr, GLValidateProgram, nullptr, nullptr, nullptr, napi_default, nullptr}, 8336 {"gLValidateProgramPipeline", nullptr, GLValidateProgramPipeline, nullptr, nullptr, nullptr, napi_default, 8337 nullptr}, 8338 {"gLVertexAttrib1f", nullptr, GLVertexAttrib1f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8339 {"gLVertexAttrib1fv", nullptr, GLVertexAttrib1fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8340 {"gLVertexAttrib2f", nullptr, GLVertexAttrib2f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8341 {"gLVertexAttrib2fv", nullptr, GLVertexAttrib2fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8342 {"gLVertexAttrib3f", nullptr, GLVertexAttrib3f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8343 {"gLVertexAttrib3fv", nullptr, GLVertexAttrib3fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8344 {"gLVertexAttrib4f", nullptr, GLVertexAttrib4f, nullptr, nullptr, nullptr, napi_default, nullptr}, 8345 {"gLVertexAttrib4fv", nullptr, GLVertexAttrib4fv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8346 {"gLVertexAttribBinding", nullptr, GLVertexAttribBinding, nullptr, nullptr, nullptr, napi_default, nullptr}, 8347 {"gLVertexAttribDivisor", nullptr, GLVertexAttribDivisor, nullptr, nullptr, nullptr, napi_default, nullptr}, 8348 {"gLVertexAttribFormat", nullptr, GLVertexAttribFormat, nullptr, nullptr, nullptr, napi_default, nullptr}, 8349 {"gLVertexAttribI4i", nullptr, GLVertexAttribI4i, nullptr, nullptr, nullptr, napi_default, nullptr}, 8350 {"gLVertexAttribI4iv", nullptr, GLVertexAttribI4iv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8351 {"gLVertexAttribI4ui", nullptr, GLVertexAttribI4ui, nullptr, nullptr, nullptr, napi_default, nullptr}, 8352 {"gLVertexAttribI4uiv", nullptr, GLVertexAttribI4uiv, nullptr, nullptr, nullptr, napi_default, nullptr}, 8353 {"gLVertexAttribIFormat", nullptr, GLVertexAttribIFormat, nullptr, nullptr, nullptr, napi_default, nullptr}, 8354 {"gLVertexAttribIPointer", nullptr, GLVertexAttribIPointer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8355 {"gLVertexAttribPointer", nullptr, GLVertexAttribPointer, nullptr, nullptr, nullptr, napi_default, nullptr}, 8356 {"gLVertexBindingDivisor", nullptr, GLVertexBindingDivisor, nullptr, nullptr, nullptr, napi_default, nullptr}, 8357 {"gLViewport", nullptr, GLViewport, nullptr, nullptr, nullptr, napi_default, nullptr}, 8358 {"gLWaitSync", nullptr, GLWaitSync, nullptr, nullptr, nullptr, napi_default, nullptr}, 8359 {"glActiveShaderProgramAbnormal", nullptr, GLActiveShaderProgramAbnormal, nullptr, nullptr, nullptr, 8360 napi_default, nullptr}, 8361 {"glActiveTextureAbnormal", nullptr, GLActiveTextureAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8362 {"glAttachShaderAbnormal", nullptr, GLAttachShaderAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8363 {"glBeginQueryAbnormal", nullptr, GLBeginQueryAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8364 {"glBeginTransformFeedbackAbnormal", nullptr, GLBeginTransformFeedbackAbnormal, nullptr, nullptr, nullptr, 8365 napi_default, nullptr}, 8366 {"glBindAttribLocationAbnormal", nullptr, GLBindAttribLocationAbnormal, nullptr, nullptr, nullptr, napi_default, 8367 nullptr}, 8368 {"glBindBufferAbnormal", nullptr, GLBindBufferAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8369 {"glBindBufferBaseAbnormal", nullptr, GLBindBufferBaseAbnormal, nullptr, nullptr, nullptr, napi_default, 8370 nullptr}, 8371 {"glBindBufferRangeAbnormal", nullptr, GLBindBufferRangeAbnormal, nullptr, nullptr, nullptr, napi_default, 8372 nullptr}, 8373 {"glBindFramebufferAbnormal", nullptr, GLBindFramebufferAbnormal, nullptr, nullptr, nullptr, napi_default, 8374 nullptr}, 8375 {"glBindImageTextureAbnormal", nullptr, GLBindImageTextureAbnormal, nullptr, nullptr, nullptr, napi_default, 8376 nullptr}, 8377 {"glBindProgramPipelineAbnormal", nullptr, GLBindProgramPipelineAbnormal, nullptr, nullptr, nullptr, 8378 napi_default, nullptr}, 8379 {"glBindRenderbufferAbnormal", nullptr, GLBindRenderbufferAbnormal, nullptr, nullptr, nullptr, napi_default, 8380 nullptr}, 8381 {"glBindSamplerAbnormal", nullptr, GLBindSamplerAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8382 {"glBindTextureAbnormal", nullptr, GLBindTextureAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8383 {"glBindTransformFeedbackAbnormal", nullptr, GLBindTransformFeedbackAbnormal, nullptr, nullptr, nullptr, 8384 napi_default, nullptr}, 8385 {"glBindVertexArrayAbnormal", nullptr, GLBindVertexArrayAbnormal, nullptr, nullptr, nullptr, napi_default, 8386 nullptr}, 8387 {"glBindVertexBufferAbnormal", nullptr, GLBindVertexBufferAbnormal, nullptr, nullptr, nullptr, napi_default, 8388 nullptr}, 8389 {"glBlendEquationAbnormal", nullptr, GLBlendEquationAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8390 {"glBlendEquationiAbnormal", nullptr, GLBlendEquationiAbnormal, nullptr, nullptr, nullptr, napi_default, 8391 nullptr}, 8392 {"glBlendEquationSeparateAbnormal", nullptr, GLBlendEquationSeparateAbnormal, nullptr, nullptr, nullptr, 8393 napi_default, nullptr}, 8394 {"glBlendEquationSeparateiAbnormal", nullptr, GLBlendEquationSeparateiAbnormal, nullptr, nullptr, nullptr, 8395 napi_default, nullptr}, 8396 {"glBlendFuncAbnormal", nullptr, GLBlendFuncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8397 {"glBlendFunciAbnormal", nullptr, GLBlendFunciAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8398 {"glBlendFuncSeparateAbnormal", nullptr, GLBlendFuncSeparateAbnormal, nullptr, nullptr, nullptr, napi_default, 8399 nullptr}, 8400 {"glBlendFuncSeparateiAbnormal", nullptr, GLBlendFuncSeparateiAbnormal, nullptr, nullptr, nullptr, napi_default, 8401 nullptr}, 8402 {"glBlitFramebufferAbnormal", nullptr, GLBlitFramebufferAbnormal, nullptr, nullptr, nullptr, napi_default, 8403 nullptr}, 8404 {"glBufferDataAbnormal", nullptr, GLBufferDataAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8405 {"glBufferSubDataAbnormal", nullptr, GLBufferSubDataAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8406 {"glCheckFramebufferStatusAbnormal", nullptr, GLCheckFramebufferStatusAbnormal, nullptr, nullptr, nullptr, 8407 napi_default, nullptr}, 8408 {"glClearAbnormal", nullptr, GLClearAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8409 {"glClearBufferfiAbnormal", nullptr, GLClearBufferfiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8410 {"glClearBufferfvAbnormal", nullptr, GLClearBufferfvAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8411 {"glClearBufferivAbnormal", nullptr, GLClearBufferivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8412 {"glClearBufferuivAbnormal", nullptr, GLClearBufferuivAbnormal, nullptr, nullptr, nullptr, napi_default, 8413 nullptr}, 8414 {"glClientWaitSyncAbnormal", nullptr, GLClientWaitSyncAbnormal, nullptr, nullptr, nullptr, napi_default, 8415 nullptr}, 8416 {"glColorMaskiAbnormal", nullptr, GLColorMaskiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8417 {"glCopyBufferSubDataAbnormal", nullptr, GLCopyBufferSubDataAbnormal, nullptr, nullptr, nullptr, napi_default, 8418 nullptr}, 8419 {"glCopyImageSubDataAbnormal", nullptr, GLCopyImageSubDataAbnormal, nullptr, nullptr, nullptr, napi_default, 8420 nullptr}, 8421 {"glCopyTexImage2DAbnormal", nullptr, GLCopyTexImage2DAbnormal, nullptr, nullptr, nullptr, napi_default, 8422 nullptr}, 8423 {"glCopyTexSubImage2DAbnormal", nullptr, GLCopyTexSubImage2DAbnormal, nullptr, nullptr, nullptr, napi_default, 8424 nullptr}, 8425 {"glCreateShaderAbnormal", nullptr, GLCreateShaderAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8426 {"glCreateShaderProgramvAbnormal", nullptr, GLCreateShaderProgramvAbnormal, nullptr, nullptr, nullptr, 8427 napi_default, nullptr}, 8428 {"glCullFaceAbnormal", nullptr, GLCullFaceAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8429 {"glDebugMessageControlAbnormal", nullptr, GLDebugMessageControlAbnormal, nullptr, nullptr, nullptr, 8430 napi_default, nullptr}, 8431 {"glDeleteBuffersAbnormal", nullptr, GLDeleteBuffersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8432 {"glDeleteFramebuffersAbnormal", nullptr, GLDeleteFramebuffersAbnormal, nullptr, nullptr, nullptr, napi_default, 8433 nullptr}, 8434 {"glDeleteProgramAbnormal", nullptr, GLDeleteProgramAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8435 {"glDeleteProgramPipelinesAbnormal", nullptr, GLDeleteProgramPipelinesAbnormal, nullptr, nullptr, nullptr, 8436 napi_default, nullptr}, 8437 {"glDeleteQueriesAbnormal", nullptr, GLDeleteQueriesAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8438 {"glDeleteRenderbuffersAbnormal", nullptr, GLDeleteRenderbuffersAbnormal, nullptr, nullptr, nullptr, 8439 napi_default, nullptr}, 8440 {"glDeleteSamplersAbnormal", nullptr, GLDeleteSamplersAbnormal, nullptr, nullptr, nullptr, napi_default, 8441 nullptr}, 8442 {"glDeleteShaderAbnormal", nullptr, GLDeleteShaderAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8443 {"glDeleteSyncAbnormal", nullptr, GLDeleteSyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8444 {"glDeleteTexturesAbnormal", nullptr, GLDeleteTexturesAbnormal, nullptr, nullptr, nullptr, napi_default, 8445 nullptr}, 8446 {"glDeleteTransformFeedbacksAbnormal", nullptr, GLDeleteTransformFeedbacksAbnormal, nullptr, nullptr, nullptr, 8447 napi_default, nullptr}, 8448 {"glDeleteVertexArraysAbnormal", nullptr, GLDeleteVertexArraysAbnormal, nullptr, nullptr, nullptr, napi_default, 8449 nullptr}, 8450 {"glDepthFuncAbnormal", nullptr, GLDepthFuncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8451 {"glDetachShaderAbnormal", nullptr, GLDetachShaderAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8452 {"glDisableAbnormal", nullptr, GLDisableAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8453 {"glDisableiAbnormal", nullptr, GLDisableiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8454 {"glDisableVertexAttribArrayAbnormal", nullptr, GLDisableVertexAttribArrayAbnormal, nullptr, nullptr, nullptr, 8455 napi_default, nullptr}, 8456 {"glDispatchComputeAbnormal", nullptr, GLDispatchComputeAbnormal, nullptr, nullptr, nullptr, napi_default, 8457 nullptr}, 8458 {"glDispatchComputeIndirectAbnormal", nullptr, GLDispatchComputeIndirectAbnormal, nullptr, nullptr, nullptr, 8459 napi_default, nullptr}, 8460 {"glDrawArraysAbnormal", nullptr, GLDrawArraysAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8461 {"glDrawArraysIndirectAbnormal", nullptr, GLDrawArraysIndirectAbnormal, nullptr, nullptr, nullptr, napi_default, 8462 nullptr}, 8463 {"glDrawArraysInstancedAbnormal", nullptr, GLDrawArraysInstancedAbnormal, nullptr, nullptr, nullptr, 8464 napi_default, nullptr}, 8465 {"glDrawBuffersAbnormal", nullptr, GLDrawBuffersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8466 {"glFlushMappedBufferRangeAbnormal", nullptr, GLFlushMappedBufferRangeAbnormal, nullptr, nullptr, nullptr, 8467 napi_default, nullptr}, 8468 {"glFramebufferParameteriAbnormal", nullptr, GLFramebufferParameteriAbnormal, nullptr, nullptr, nullptr, 8469 napi_default, nullptr}, 8470 {"glFramebufferRenderbufferAbnormal", nullptr, GLFramebufferRenderbufferAbnormal, nullptr, nullptr, nullptr, 8471 napi_default, nullptr}, 8472 {"glFramebufferTextureAbnormal", nullptr, GLFramebufferTextureAbnormal, nullptr, nullptr, nullptr, napi_default, 8473 nullptr}, 8474 {"glFramebufferTexture2DAbnormal", nullptr, GLFramebufferTexture2DAbnormal, nullptr, nullptr, nullptr, 8475 napi_default, nullptr}, 8476 {"glFramebufferTextureLayerAbnormal", nullptr, GLFramebufferTextureLayerAbnormal, nullptr, nullptr, nullptr, 8477 napi_default, nullptr}, 8478 {"glFrontFaceAbnormal", nullptr, GLFrontFaceAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8479 {"glGenBuffersAbnormal", nullptr, GLGenBuffersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8480 {"glGenerateMipmapAbnormal", nullptr, GLGenerateMipmapAbnormal, nullptr, nullptr, nullptr, napi_default, 8481 nullptr}, 8482 {"glGenFramebuffersAbnormal", nullptr, GLGenFramebuffersAbnormal, nullptr, nullptr, nullptr, napi_default, 8483 nullptr}, 8484 {"glGenProgramPipelinesAbnormal", nullptr, GLGenProgramPipelinesAbnormal, nullptr, nullptr, nullptr, 8485 napi_default, nullptr}, 8486 {"glGenQueriesAbnormal", nullptr, GLGenQueriesAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8487 {"glGenRenderbuffersAbnormal", nullptr, GLGenRenderbuffersAbnormal, nullptr, nullptr, nullptr, napi_default, 8488 nullptr}, 8489 {"glGenSamplersAbnormal", nullptr, GLGenSamplersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8490 {"glGenTexturesAbnormal", nullptr, GLGenTexturesAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8491 {"glGenTransformFeedbacksAbnormal", nullptr, GLGenTransformFeedbacksAbnormal, nullptr, nullptr, nullptr, 8492 napi_default, nullptr}, 8493 {"glGenVertexArraysAbnormal", nullptr, GLGenVertexArraysAbnormal, nullptr, nullptr, nullptr, napi_default, 8494 nullptr}, 8495 {"glGetActiveAttribAbnormal", nullptr, GLGetActiveAttribAbnormal, nullptr, nullptr, nullptr, napi_default, 8496 nullptr}, 8497 {"glGetAttachedShadersAbnormal", nullptr, GLGetAttachedShadersAbnormal, nullptr, nullptr, nullptr, napi_default, 8498 nullptr}, 8499 {"glGetAttribLocationAbnormal", nullptr, GLGetAttribLocationAbnormal, nullptr, nullptr, nullptr, napi_default, 8500 nullptr}, 8501 {"glGetBooleani_vAbnormal", nullptr, GLGetBooleani_vAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8502 {"glGetBooleanvAbnormal", nullptr, GLGetBooleanvAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8503 {"glGetBufferParameteri64vAbnormal", nullptr, GLGetBufferParameteri64vAbnormal, nullptr, nullptr, nullptr, 8504 napi_default, nullptr}, 8505 {"glGetBufferParameterivAbnormal", nullptr, GLGetBufferParameterivAbnormal, nullptr, nullptr, nullptr, 8506 napi_default, nullptr}, 8507 {"glGetBufferPointervAbnormal", nullptr, GLGetBufferPointervAbnormal, nullptr, nullptr, nullptr, napi_default, 8508 nullptr}, 8509 {"glGetFloatvAbnormal", nullptr, GLGetFloatvAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8510 {"glGetFragDataLocationAbnormal", nullptr, GLGetFragDataLocationAbnormal, nullptr, nullptr, nullptr, 8511 napi_default, nullptr}, 8512 {"glGetFramebufferAttachmentParameterivAbnormal", nullptr, GLGetFramebufferAttachmentParameterivAbnormal, 8513 nullptr, nullptr, nullptr, napi_default, nullptr}, 8514 {"glGetFramebufferParameterivAbnormal", nullptr, GLGetFramebufferParameterivAbnormal, nullptr, nullptr, nullptr, 8515 napi_default, nullptr}, 8516 {"glGetInteger64i_vAbnormal", nullptr, GLGetInteger64i_vAbnormal, nullptr, nullptr, nullptr, napi_default, 8517 nullptr}, 8518 {"glGetInteger64vAbnormal", nullptr, GLGetInteger64vAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8519 {"glGetIntegeri_vAbnormal", nullptr, GLGetIntegeri_vAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8520 {"glGetIntegervAbnormal", nullptr, GLGetIntegervAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8521 {"glGetInternalformativAbnormal", nullptr, GLGetInternalformativAbnormal, nullptr, nullptr, nullptr, 8522 napi_default, nullptr}, 8523 {"glGetObjectLabelAbnormal", nullptr, GLGetObjectLabelAbnormal, nullptr, nullptr, nullptr, napi_default, 8524 nullptr}, 8525 {"glGetObjectPtrLabelAbnormal", nullptr, GLGetObjectPtrLabelAbnormal, nullptr, nullptr, nullptr, napi_default, 8526 nullptr}, 8527 {"glGetPointervAbnormal", nullptr, GLGetPointervAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8528 {"glGetProgramBinaryAbnormal", nullptr, GLGetProgramBinaryAbnormal, nullptr, nullptr, nullptr, napi_default, 8529 nullptr}, 8530 {"glGetProgramInterfaceivAbnormal", nullptr, GLGetProgramInterfaceivAbnormal, nullptr, nullptr, nullptr, 8531 napi_default, nullptr}, 8532 {"glGetProgramivAbnormal", nullptr, GLGetProgramivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8533 {"glGetProgramPipelineivAbnormal", nullptr, GLGetProgramPipelineivAbnormal, nullptr, nullptr, nullptr, 8534 napi_default, nullptr}, 8535 {"glGetProgramResourceIndexAbnormal", nullptr, GLGetProgramResourceIndexAbnormal, nullptr, nullptr, nullptr, 8536 napi_default, nullptr}, 8537 {"glGetProgramResourceivAbnormal", nullptr, GLGetProgramResourceivAbnormal, nullptr, nullptr, nullptr, 8538 napi_default, nullptr}, 8539 {"glGetProgramResourceLocationAbnormal", nullptr, GLGetProgramResourceLocationAbnormal, nullptr, nullptr, 8540 nullptr, napi_default, nullptr}, 8541 {"glGetProgramResourceNameAbnormal", nullptr, GLGetProgramResourceNameAbnormal, nullptr, nullptr, nullptr, 8542 napi_default, nullptr}, 8543 {"glGetQueryivAbnormal", nullptr, GLGetQueryivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8544 {"glGetQueryObjectuivAbnormal", nullptr, GLGetQueryObjectuivAbnormal, nullptr, nullptr, nullptr, napi_default, 8545 nullptr}, 8546 {"glGetRenderbufferParameterivAbnormal", nullptr, GLGetRenderbufferParameterivAbnormal, nullptr, nullptr, 8547 nullptr, napi_default, nullptr}, 8548 {"glGetSamplerParameterfvAbnormal", nullptr, GLGetSamplerParameterfvAbnormal, nullptr, nullptr, nullptr, 8549 napi_default, nullptr}, 8550 {"glGetSamplerParameterIivAbnormal", nullptr, GLGetSamplerParameterIivAbnormal, nullptr, nullptr, nullptr, 8551 napi_default, nullptr}, 8552 {"glGetSamplerParameterIuivAbnormal", nullptr, GLGetSamplerParameterIuivAbnormal, nullptr, nullptr, nullptr, 8553 napi_default, nullptr}, 8554 {"glGetSamplerParameterivAbnormal", nullptr, GLGetSamplerParameterivAbnormal, nullptr, nullptr, nullptr, 8555 napi_default, nullptr}, 8556 {"glUniform1fAbnormal", nullptr, GLUniform1fAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8557 {"glUniform1fvAbnormal", nullptr, GLUniform1fvAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8558 {"glUniform1iAbnormal", nullptr, GLUniform1iAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8559 {"glUniform1ivAbnormal", nullptr, GLUniform1ivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8560 {"glUniform1uiAbnormal", nullptr, GLUniform1uiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8561 {"glUniform1uivAbnormal", nullptr, GLUniform1uivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8562 {"glUniform2fAbnormal", nullptr, GLUniform2fAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8563 {"glUniform2fvAbnormal", nullptr, GLUniform2fvAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8564 {"glUniform2iAbnormal", nullptr, GLUniform2iAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8565 {"glUniform2ivAbnormal", nullptr, GLUniform2ivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8566 {"glUniform2uiAbnormal", nullptr, GLUniform2uiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8567 {"glUniform2uivAbnormal", nullptr, GLUniform2uivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8568 {"glUniform3fAbnormal", nullptr, GLUniform3fAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8569 {"glUniform3fvAbnormal", nullptr, GLUniform3fvAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8570 {"glUniform3iAbnormal", nullptr, GLUniform3iAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8571 {"glUniform3ivAbnormal", nullptr, GLUniform3ivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8572 {"glUniform3uiAbnormal", nullptr, GLUniform3uiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8573 {"glUniform3uivAbnormal", nullptr, GLUniform3uivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8574 {"glUniform4fAbnormal", nullptr, GLUniform4fAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8575 {"glUniform4fvAbnormal", nullptr, GLUniform4fvAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8576 {"glUniform4iAbnormal", nullptr, GLUniform4iAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8577 {"glUniform4ivAbnormal", nullptr, GLUniform4ivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8578 {"glUniform4uiAbnormal", nullptr, GLUniform4uiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8579 {"glUniform4uivAbnormal", nullptr, GLUniform4uivAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8580 {"glUniformBlockBindingAbnormal", nullptr, GLUniformBlockBindingAbnormal, nullptr, nullptr, nullptr, 8581 napi_default, nullptr}, 8582 {"glUniformMatrix2fvAbnormal", nullptr, GLUniformMatrix2fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8583 nullptr}, 8584 {"glUniformMatrix2x3fvAbnormal", nullptr, GLUniformMatrix2x3fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8585 nullptr}, 8586 {"glUniformMatrix2x4fvAbnormal", nullptr, GLUniformMatrix2x4fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8587 nullptr}, 8588 {"glUniformMatrix3fvAbnormal", nullptr, GLUniformMatrix3fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8589 nullptr}, 8590 {"glUniformMatrix3x2fvAbnormal", nullptr, GLUniformMatrix3x2fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8591 nullptr}, 8592 {"glUniformMatrix3x4fvAbnormal", nullptr, GLUniformMatrix3x4fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8593 nullptr}, 8594 {"glUniformMatrix4fvAbnormal", nullptr, GLUniformMatrix4fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8595 nullptr}, 8596 {"glUniformMatrix4x2fvAbnormal", nullptr, GLUniformMatrix4x2fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8597 nullptr}, 8598 {"glUniformMatrix4x3fvAbnormal", nullptr, GLUniformMatrix4x3fvAbnormal, nullptr, nullptr, nullptr, napi_default, 8599 nullptr}, 8600 {"glCompileShaderAbnormal", nullptr, GLCompileShaderAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8601 {"glCompressedTexImage2DAbnormal", nullptr, GLCompressedTexImage2DAbnormal, nullptr, nullptr, nullptr, 8602 napi_default, nullptr}, 8603 {"glCompressedTexImage3DAbnormal", nullptr, GLCompressedTexImage3DAbnormal, nullptr, nullptr, nullptr, 8604 napi_default, nullptr}, 8605 {"glCompressedTexSubImage2DAbnormal", nullptr, GLCompressedTexSubImage2DAbnormal, nullptr, nullptr, nullptr, 8606 napi_default, nullptr}, 8607 {"glCompressedTexSubImage3DAbnormal", nullptr, GLCompressedTexSubImage3DAbnormal, nullptr, nullptr, nullptr, 8608 napi_default, nullptr}, 8609 {"glCopyTexSubImage3DAbnormal", nullptr, GLCopyTexSubImage3DAbnormal, nullptr, nullptr, nullptr, napi_default, 8610 nullptr}, 8611 {"glDrawElementsAbnormal", nullptr, GLDrawElementsAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8612 {"glDrawElementsBaseVertexAbnormal", nullptr, GLDrawElementsBaseVertexAbnormal, nullptr, nullptr, nullptr, 8613 napi_default, nullptr}, 8614 {"glDrawElementsIndirectAbnormal", nullptr, GLDrawElementsIndirectAbnormal, nullptr, nullptr, nullptr, 8615 napi_default, nullptr}, 8616 {"glDrawElementsInstancedAbnormal", nullptr, GLDrawElementsInstancedAbnormal, nullptr, nullptr, nullptr, 8617 napi_default, nullptr}, 8618 {"glDrawElementsInstancedBaseVertexAbnormal", nullptr, GLDrawElementsInstancedBaseVertexAbnormal, nullptr, 8619 nullptr, nullptr, napi_default, nullptr}, 8620 {"glDrawRangeElementsAbnormal", nullptr, GLDrawRangeElementsAbnormal, nullptr, nullptr, nullptr, napi_default, 8621 nullptr}, 8622 {"glDrawRangeElementsBaseVertexAbnormal", nullptr, GLDrawRangeElementsBaseVertexAbnormal, nullptr, nullptr, 8623 nullptr, napi_default, nullptr}, 8624 {"glEnableAbnormal", nullptr, GLEnableAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8625 {"glEnableiAbnormal", nullptr, GLEnableiAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8626 {"glEnableVertexAttribArrayAbnormal", nullptr, GLEnableVertexAttribArrayAbnormal, nullptr, nullptr, nullptr, 8627 napi_default, nullptr}, 8628 {"glEndQueryAbnormal", nullptr, GLEndQueryAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8629 {"glEndTransformFeedbackAbnormal", nullptr, GLEndTransformFeedbackAbnormal, nullptr, nullptr, nullptr, 8630 napi_default, nullptr}, 8631 {"glFenceSyncAbnormal", nullptr, GLFenceSyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 8632 8633 }; 8634 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); 8635 return exports; 8636} 8637EXTERN_C_END 8638 8639static napi_module demoModule = { 8640 .nm_version = 1, 8641 .nm_flags = 0, 8642 .nm_filename = nullptr, 8643 .nm_register_func = Init, 8644 .nm_modname = "media", 8645 .nm_priv = ((void *)0), 8646 .reserved = {0}, 8647}; 8648 8649extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); } 8650