entry_points_gles_3_1_autogen.cpp (84940B)
1 // GENERATED FILE - DO NOT EDIT. 2 // Generated by generate_entry_points.py using data from gl.xml. 3 // 4 // Copyright 2020 The ANGLE Project Authors. All rights reserved. 5 // Use of this source code is governed by a BSD-style license that can be 6 // found in the LICENSE file. 7 // 8 // entry_points_gles_3_1_autogen.cpp: 9 // Defines the GLES 3.1 entry points. 10 11 #include "libGLESv2/entry_points_gles_3_1_autogen.h" 12 13 #include "common/entry_points_enum_autogen.h" 14 #include "libANGLE/Context.h" 15 #include "libANGLE/Context.inl.h" 16 #include "libANGLE/capture/capture_gles_3_1_autogen.h" 17 #include "libANGLE/capture/gl_enum_utils.h" 18 #include "libANGLE/entry_points_utils.h" 19 #include "libANGLE/validationES31.h" 20 #include "libGLESv2/global_state.h" 21 22 using namespace gl; 23 24 extern "C" { 25 void GL_APIENTRY GL_ActiveShaderProgram(GLuint pipeline, GLuint program) 26 { 27 Context *context = GetValidGlobalContext(); 28 EVENT(context, GLActiveShaderProgram, "context = %d, pipeline = %u, program = %u", CID(context), 29 pipeline, program); 30 31 if (context) 32 { 33 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); 34 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 35 SCOPED_SHARE_CONTEXT_LOCK(context); 36 bool isCallValid = 37 (context->skipValidation() || 38 ValidateActiveShaderProgram(context, angle::EntryPoint::GLActiveShaderProgram, 39 pipelinePacked, programPacked)); 40 if (isCallValid) 41 { 42 context->activeShaderProgram(pipelinePacked, programPacked); 43 } 44 ANGLE_CAPTURE_GL(ActiveShaderProgram, isCallValid, context, pipelinePacked, programPacked); 45 } 46 else 47 { 48 GenerateContextLostErrorOnCurrentGlobalContext(); 49 } 50 } 51 52 void GL_APIENTRY GL_BindImageTexture(GLuint unit, 53 GLuint texture, 54 GLint level, 55 GLboolean layered, 56 GLint layer, 57 GLenum access, 58 GLenum format) 59 { 60 Context *context = GetValidGlobalContext(); 61 EVENT(context, GLBindImageTexture, 62 "context = %d, unit = %u, texture = %u, level = %d, layered = %s, layer = %d, access = " 63 "%s, format = %s", 64 CID(context), unit, texture, level, GLbooleanToString(layered), layer, 65 GLenumToString(GLESEnum::BufferAccessARB, access), 66 GLenumToString(GLESEnum::InternalFormat, format)); 67 68 if (context) 69 { 70 TextureID texturePacked = PackParam<TextureID>(texture); 71 SCOPED_SHARE_CONTEXT_LOCK(context); 72 bool isCallValid = 73 (context->skipValidation() || 74 ValidateBindImageTexture(context, angle::EntryPoint::GLBindImageTexture, unit, 75 texturePacked, level, layered, layer, access, format)); 76 if (isCallValid) 77 { 78 context->bindImageTexture(unit, texturePacked, level, layered, layer, access, format); 79 } 80 ANGLE_CAPTURE_GL(BindImageTexture, isCallValid, context, unit, texturePacked, level, 81 layered, layer, access, format); 82 } 83 else 84 { 85 GenerateContextLostErrorOnCurrentGlobalContext(); 86 } 87 } 88 89 void GL_APIENTRY GL_BindProgramPipeline(GLuint pipeline) 90 { 91 Context *context = GetValidGlobalContext(); 92 EVENT(context, GLBindProgramPipeline, "context = %d, pipeline = %u", CID(context), pipeline); 93 94 if (context) 95 { 96 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); 97 SCOPED_SHARE_CONTEXT_LOCK(context); 98 bool isCallValid = (context->skipValidation() || 99 ValidateBindProgramPipeline( 100 context, angle::EntryPoint::GLBindProgramPipeline, pipelinePacked)); 101 if (isCallValid) 102 { 103 context->bindProgramPipeline(pipelinePacked); 104 } 105 ANGLE_CAPTURE_GL(BindProgramPipeline, isCallValid, context, pipelinePacked); 106 } 107 else 108 { 109 GenerateContextLostErrorOnCurrentGlobalContext(); 110 } 111 } 112 113 void GL_APIENTRY GL_BindVertexBuffer(GLuint bindingindex, 114 GLuint buffer, 115 GLintptr offset, 116 GLsizei stride) 117 { 118 Context *context = GetValidGlobalContext(); 119 EVENT(context, GLBindVertexBuffer, 120 "context = %d, bindingindex = %u, buffer = %u, offset = %llu, stride = %d", CID(context), 121 bindingindex, buffer, static_cast<unsigned long long>(offset), stride); 122 123 if (context) 124 { 125 BufferID bufferPacked = PackParam<BufferID>(buffer); 126 SCOPED_SHARE_CONTEXT_LOCK(context); 127 bool isCallValid = (context->skipValidation() || 128 ValidateBindVertexBuffer(context, angle::EntryPoint::GLBindVertexBuffer, 129 bindingindex, bufferPacked, offset, stride)); 130 if (isCallValid) 131 { 132 context->bindVertexBuffer(bindingindex, bufferPacked, offset, stride); 133 } 134 ANGLE_CAPTURE_GL(BindVertexBuffer, isCallValid, context, bindingindex, bufferPacked, offset, 135 stride); 136 } 137 else 138 { 139 GenerateContextLostErrorOnCurrentGlobalContext(); 140 } 141 } 142 143 GLuint GL_APIENTRY GL_CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings) 144 { 145 Context *context = GetValidGlobalContext(); 146 EVENT(context, GLCreateShaderProgramv, 147 "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context), 148 GLenumToString(GLESEnum::ShaderType, type), count, (uintptr_t)strings); 149 150 GLuint returnValue; 151 if (context) 152 { 153 ShaderType typePacked = PackParam<ShaderType>(type); 154 SCOPED_SHARE_CONTEXT_LOCK(context); 155 bool isCallValid = 156 (context->skipValidation() || 157 ValidateCreateShaderProgramv(context, angle::EntryPoint::GLCreateShaderProgramv, 158 typePacked, count, strings)); 159 if (isCallValid) 160 { 161 returnValue = context->createShaderProgramv(typePacked, count, strings); 162 } 163 else 164 { 165 returnValue = 166 GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramv, GLuint>(); 167 } 168 ANGLE_CAPTURE_GL(CreateShaderProgramv, isCallValid, context, typePacked, count, strings, 169 returnValue); 170 } 171 else 172 { 173 GenerateContextLostErrorOnCurrentGlobalContext(); 174 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramv, GLuint>(); 175 } 176 return returnValue; 177 } 178 179 void GL_APIENTRY GL_DeleteProgramPipelines(GLsizei n, const GLuint *pipelines) 180 { 181 Context *context = GetValidGlobalContext(); 182 EVENT(context, GLDeleteProgramPipelines, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", 183 CID(context), n, (uintptr_t)pipelines); 184 185 if (context) 186 { 187 const ProgramPipelineID *pipelinesPacked = PackParam<const ProgramPipelineID *>(pipelines); 188 SCOPED_SHARE_CONTEXT_LOCK(context); 189 bool isCallValid = 190 (context->skipValidation() || 191 ValidateDeleteProgramPipelines(context, angle::EntryPoint::GLDeleteProgramPipelines, n, 192 pipelinesPacked)); 193 if (isCallValid) 194 { 195 context->deleteProgramPipelines(n, pipelinesPacked); 196 } 197 ANGLE_CAPTURE_GL(DeleteProgramPipelines, isCallValid, context, n, pipelinesPacked); 198 } 199 else 200 { 201 GenerateContextLostErrorOnCurrentGlobalContext(); 202 } 203 } 204 205 void GL_APIENTRY GL_DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) 206 { 207 Context *context = GetValidGlobalContext(); 208 EVENT(context, GLDispatchCompute, 209 "context = %d, num_groups_x = %u, num_groups_y = %u, num_groups_z = %u", CID(context), 210 num_groups_x, num_groups_y, num_groups_z); 211 212 if (context) 213 { 214 SCOPED_SHARE_CONTEXT_LOCK(context); 215 bool isCallValid = (context->skipValidation() || 216 ValidateDispatchCompute(context, angle::EntryPoint::GLDispatchCompute, 217 num_groups_x, num_groups_y, num_groups_z)); 218 if (isCallValid) 219 { 220 context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z); 221 } 222 ANGLE_CAPTURE_GL(DispatchCompute, isCallValid, context, num_groups_x, num_groups_y, 223 num_groups_z); 224 } 225 else 226 { 227 GenerateContextLostErrorOnCurrentGlobalContext(); 228 } 229 } 230 231 void GL_APIENTRY GL_DispatchComputeIndirect(GLintptr indirect) 232 { 233 Context *context = GetValidGlobalContext(); 234 EVENT(context, GLDispatchComputeIndirect, "context = %d, indirect = %llu", CID(context), 235 static_cast<unsigned long long>(indirect)); 236 237 if (context) 238 { 239 SCOPED_SHARE_CONTEXT_LOCK(context); 240 bool isCallValid = (context->skipValidation() || 241 ValidateDispatchComputeIndirect( 242 context, angle::EntryPoint::GLDispatchComputeIndirect, indirect)); 243 if (isCallValid) 244 { 245 context->dispatchComputeIndirect(indirect); 246 } 247 ANGLE_CAPTURE_GL(DispatchComputeIndirect, isCallValid, context, indirect); 248 } 249 else 250 { 251 GenerateContextLostErrorOnCurrentGlobalContext(); 252 } 253 } 254 255 void GL_APIENTRY GL_DrawArraysIndirect(GLenum mode, const void *indirect) 256 { 257 Context *context = GetValidGlobalContext(); 258 EVENT(context, GLDrawArraysIndirect, "context = %d, mode = %s, indirect = 0x%016" PRIxPTR "", 259 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)indirect); 260 261 if (context) 262 { 263 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); 264 SCOPED_SHARE_CONTEXT_LOCK(context); 265 bool isCallValid = 266 (context->skipValidation() || 267 ValidateDrawArraysIndirect(context, angle::EntryPoint::GLDrawArraysIndirect, 268 modePacked, indirect)); 269 if (isCallValid) 270 { 271 context->drawArraysIndirect(modePacked, indirect); 272 } 273 ANGLE_CAPTURE_GL(DrawArraysIndirect, isCallValid, context, modePacked, indirect); 274 } 275 else 276 { 277 GenerateContextLostErrorOnCurrentGlobalContext(); 278 } 279 } 280 281 void GL_APIENTRY GL_DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) 282 { 283 Context *context = GetValidGlobalContext(); 284 EVENT(context, GLDrawElementsIndirect, 285 "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR "", CID(context), 286 GLenumToString(GLESEnum::PrimitiveType, mode), 287 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indirect); 288 289 if (context) 290 { 291 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); 292 DrawElementsType typePacked = PackParam<DrawElementsType>(type); 293 SCOPED_SHARE_CONTEXT_LOCK(context); 294 bool isCallValid = 295 (context->skipValidation() || 296 ValidateDrawElementsIndirect(context, angle::EntryPoint::GLDrawElementsIndirect, 297 modePacked, typePacked, indirect)); 298 if (isCallValid) 299 { 300 context->drawElementsIndirect(modePacked, typePacked, indirect); 301 } 302 ANGLE_CAPTURE_GL(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, 303 indirect); 304 } 305 else 306 { 307 GenerateContextLostErrorOnCurrentGlobalContext(); 308 } 309 } 310 311 void GL_APIENTRY GL_FramebufferParameteri(GLenum target, GLenum pname, GLint param) 312 { 313 Context *context = GetValidGlobalContext(); 314 EVENT(context, GLFramebufferParameteri, "context = %d, target = %s, pname = %s, param = %d", 315 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), 316 GLenumToString(GLESEnum::FramebufferParameterName, pname), param); 317 318 if (context) 319 { 320 SCOPED_SHARE_CONTEXT_LOCK(context); 321 bool isCallValid = 322 (context->skipValidation() || 323 ValidateFramebufferParameteri(context, angle::EntryPoint::GLFramebufferParameteri, 324 target, pname, param)); 325 if (isCallValid) 326 { 327 context->framebufferParameteri(target, pname, param); 328 } 329 ANGLE_CAPTURE_GL(FramebufferParameteri, isCallValid, context, target, pname, param); 330 } 331 else 332 { 333 GenerateContextLostErrorOnCurrentGlobalContext(); 334 } 335 } 336 337 void GL_APIENTRY GL_GenProgramPipelines(GLsizei n, GLuint *pipelines) 338 { 339 Context *context = GetValidGlobalContext(); 340 EVENT(context, GLGenProgramPipelines, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", 341 CID(context), n, (uintptr_t)pipelines); 342 343 if (context) 344 { 345 ProgramPipelineID *pipelinesPacked = PackParam<ProgramPipelineID *>(pipelines); 346 SCOPED_SHARE_CONTEXT_LOCK(context); 347 bool isCallValid = 348 (context->skipValidation() || 349 ValidateGenProgramPipelines(context, angle::EntryPoint::GLGenProgramPipelines, n, 350 pipelinesPacked)); 351 if (isCallValid) 352 { 353 context->genProgramPipelines(n, pipelinesPacked); 354 } 355 ANGLE_CAPTURE_GL(GenProgramPipelines, isCallValid, context, n, pipelinesPacked); 356 } 357 else 358 { 359 GenerateContextLostErrorOnCurrentGlobalContext(); 360 } 361 } 362 363 void GL_APIENTRY GL_GetBooleani_v(GLenum target, GLuint index, GLboolean *data) 364 { 365 Context *context = GetValidGlobalContext(); 366 EVENT(context, GLGetBooleani_v, 367 "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), 368 GLenumToString(GLESEnum::BufferTargetARB, target), index, (uintptr_t)data); 369 370 if (context) 371 { 372 SCOPED_SHARE_CONTEXT_LOCK(context); 373 bool isCallValid = (context->skipValidation() || 374 ValidateGetBooleani_v(context, angle::EntryPoint::GLGetBooleani_v, 375 target, index, data)); 376 if (isCallValid) 377 { 378 context->getBooleani_v(target, index, data); 379 } 380 ANGLE_CAPTURE_GL(GetBooleani_v, isCallValid, context, target, index, data); 381 } 382 else 383 { 384 GenerateContextLostErrorOnCurrentGlobalContext(); 385 } 386 } 387 388 void GL_APIENTRY GL_GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params) 389 { 390 Context *context = GetValidGlobalContext(); 391 EVENT(context, GLGetFramebufferParameteriv, 392 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), 393 GLenumToString(GLESEnum::FramebufferTarget, target), 394 GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); 395 396 if (context) 397 { 398 SCOPED_SHARE_CONTEXT_LOCK(context); 399 bool isCallValid = 400 (context->skipValidation() || 401 ValidateGetFramebufferParameteriv( 402 context, angle::EntryPoint::GLGetFramebufferParameteriv, target, pname, params)); 403 if (isCallValid) 404 { 405 context->getFramebufferParameteriv(target, pname, params); 406 } 407 ANGLE_CAPTURE_GL(GetFramebufferParameteriv, isCallValid, context, target, pname, params); 408 } 409 else 410 { 411 GenerateContextLostErrorOnCurrentGlobalContext(); 412 } 413 } 414 415 void GL_APIENTRY GL_GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val) 416 { 417 Context *context = GetValidGlobalContext(); 418 EVENT(context, GLGetMultisamplefv, 419 "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context), 420 GLenumToString(GLESEnum::AllEnums, pname), index, (uintptr_t)val); 421 422 if (context) 423 { 424 SCOPED_SHARE_CONTEXT_LOCK(context); 425 bool isCallValid = (context->skipValidation() || 426 ValidateGetMultisamplefv(context, angle::EntryPoint::GLGetMultisamplefv, 427 pname, index, val)); 428 if (isCallValid) 429 { 430 context->getMultisamplefv(pname, index, val); 431 } 432 ANGLE_CAPTURE_GL(GetMultisamplefv, isCallValid, context, pname, index, val); 433 } 434 else 435 { 436 GenerateContextLostErrorOnCurrentGlobalContext(); 437 } 438 } 439 440 void GL_APIENTRY GL_GetProgramInterfaceiv(GLuint program, 441 GLenum programInterface, 442 GLenum pname, 443 GLint *params) 444 { 445 Context *context = GetValidGlobalContext(); 446 EVENT(context, GLGetProgramInterfaceiv, 447 "context = %d, program = %u, programInterface = %s, pname = %s, params = 0x%016" PRIxPTR 448 "", 449 CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), 450 GLenumToString(GLESEnum::ProgramInterfacePName, pname), (uintptr_t)params); 451 452 if (context) 453 { 454 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 455 SCOPED_SHARE_CONTEXT_LOCK(context); 456 bool isCallValid = 457 (context->skipValidation() || 458 ValidateGetProgramInterfaceiv(context, angle::EntryPoint::GLGetProgramInterfaceiv, 459 programPacked, programInterface, pname, params)); 460 if (isCallValid) 461 { 462 context->getProgramInterfaceiv(programPacked, programInterface, pname, params); 463 } 464 ANGLE_CAPTURE_GL(GetProgramInterfaceiv, isCallValid, context, programPacked, 465 programInterface, pname, params); 466 } 467 else 468 { 469 GenerateContextLostErrorOnCurrentGlobalContext(); 470 } 471 } 472 473 void GL_APIENTRY GL_GetProgramPipelineInfoLog(GLuint pipeline, 474 GLsizei bufSize, 475 GLsizei *length, 476 GLchar *infoLog) 477 { 478 Context *context = GetValidGlobalContext(); 479 EVENT(context, GLGetProgramPipelineInfoLog, 480 "context = %d, pipeline = %u, bufSize = %d, length = 0x%016" PRIxPTR 481 ", infoLog = 0x%016" PRIxPTR "", 482 CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog); 483 484 if (context) 485 { 486 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); 487 SCOPED_SHARE_CONTEXT_LOCK(context); 488 bool isCallValid = (context->skipValidation() || 489 ValidateGetProgramPipelineInfoLog( 490 context, angle::EntryPoint::GLGetProgramPipelineInfoLog, 491 pipelinePacked, bufSize, length, infoLog)); 492 if (isCallValid) 493 { 494 context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog); 495 } 496 ANGLE_CAPTURE_GL(GetProgramPipelineInfoLog, isCallValid, context, pipelinePacked, bufSize, 497 length, infoLog); 498 } 499 else 500 { 501 GenerateContextLostErrorOnCurrentGlobalContext(); 502 } 503 } 504 505 void GL_APIENTRY GL_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params) 506 { 507 Context *context = GetValidGlobalContext(); 508 EVENT(context, GLGetProgramPipelineiv, 509 "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), 510 pipeline, GLenumToString(GLESEnum::PipelineParameterName, pname), (uintptr_t)params); 511 512 if (context) 513 { 514 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); 515 SCOPED_SHARE_CONTEXT_LOCK(context); 516 bool isCallValid = 517 (context->skipValidation() || 518 ValidateGetProgramPipelineiv(context, angle::EntryPoint::GLGetProgramPipelineiv, 519 pipelinePacked, pname, params)); 520 if (isCallValid) 521 { 522 context->getProgramPipelineiv(pipelinePacked, pname, params); 523 } 524 ANGLE_CAPTURE_GL(GetProgramPipelineiv, isCallValid, context, pipelinePacked, pname, params); 525 } 526 else 527 { 528 GenerateContextLostErrorOnCurrentGlobalContext(); 529 } 530 } 531 532 GLuint GL_APIENTRY GL_GetProgramResourceIndex(GLuint program, 533 GLenum programInterface, 534 const GLchar *name) 535 { 536 Context *context = GetValidGlobalContext(); 537 EVENT(context, GLGetProgramResourceIndex, 538 "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", 539 CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), 540 (uintptr_t)name); 541 542 GLuint returnValue; 543 if (context) 544 { 545 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 546 SCOPED_SHARE_CONTEXT_LOCK(context); 547 bool isCallValid = 548 (context->skipValidation() || 549 ValidateGetProgramResourceIndex(context, angle::EntryPoint::GLGetProgramResourceIndex, 550 programPacked, programInterface, name)); 551 if (isCallValid) 552 { 553 returnValue = context->getProgramResourceIndex(programPacked, programInterface, name); 554 } 555 else 556 { 557 returnValue = 558 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceIndex, GLuint>(); 559 } 560 ANGLE_CAPTURE_GL(GetProgramResourceIndex, isCallValid, context, programPacked, 561 programInterface, name, returnValue); 562 } 563 else 564 { 565 GenerateContextLostErrorOnCurrentGlobalContext(); 566 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceIndex, GLuint>(); 567 } 568 return returnValue; 569 } 570 571 GLint GL_APIENTRY GL_GetProgramResourceLocation(GLuint program, 572 GLenum programInterface, 573 const GLchar *name) 574 { 575 Context *context = GetValidGlobalContext(); 576 EVENT(context, GLGetProgramResourceLocation, 577 "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", 578 CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), 579 (uintptr_t)name); 580 581 GLint returnValue; 582 if (context) 583 { 584 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 585 SCOPED_SHARE_CONTEXT_LOCK(context); 586 bool isCallValid = (context->skipValidation() || 587 ValidateGetProgramResourceLocation( 588 context, angle::EntryPoint::GLGetProgramResourceLocation, 589 programPacked, programInterface, name)); 590 if (isCallValid) 591 { 592 returnValue = 593 context->getProgramResourceLocation(programPacked, programInterface, name); 594 } 595 else 596 { 597 returnValue = 598 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocation, GLint>(); 599 } 600 ANGLE_CAPTURE_GL(GetProgramResourceLocation, isCallValid, context, programPacked, 601 programInterface, name, returnValue); 602 } 603 else 604 { 605 GenerateContextLostErrorOnCurrentGlobalContext(); 606 returnValue = 607 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocation, GLint>(); 608 } 609 return returnValue; 610 } 611 612 void GL_APIENTRY GL_GetProgramResourceName(GLuint program, 613 GLenum programInterface, 614 GLuint index, 615 GLsizei bufSize, 616 GLsizei *length, 617 GLchar *name) 618 { 619 Context *context = GetValidGlobalContext(); 620 EVENT(context, GLGetProgramResourceName, 621 "context = %d, program = %u, programInterface = %s, index = %u, bufSize = %d, length = " 622 "0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "", 623 CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), 624 index, bufSize, (uintptr_t)length, (uintptr_t)name); 625 626 if (context) 627 { 628 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 629 SCOPED_SHARE_CONTEXT_LOCK(context); 630 bool isCallValid = (context->skipValidation() || 631 ValidateGetProgramResourceName( 632 context, angle::EntryPoint::GLGetProgramResourceName, programPacked, 633 programInterface, index, bufSize, length, name)); 634 if (isCallValid) 635 { 636 context->getProgramResourceName(programPacked, programInterface, index, bufSize, length, 637 name); 638 } 639 ANGLE_CAPTURE_GL(GetProgramResourceName, isCallValid, context, programPacked, 640 programInterface, index, bufSize, length, name); 641 } 642 else 643 { 644 GenerateContextLostErrorOnCurrentGlobalContext(); 645 } 646 } 647 648 void GL_APIENTRY GL_GetProgramResourceiv(GLuint program, 649 GLenum programInterface, 650 GLuint index, 651 GLsizei propCount, 652 const GLenum *props, 653 GLsizei count, 654 GLsizei *length, 655 GLint *params) 656 { 657 Context *context = GetValidGlobalContext(); 658 EVENT(context, GLGetProgramResourceiv, 659 "context = %d, program = %u, programInterface = %s, index = %u, propCount = %d, props = " 660 "0x%016" PRIxPTR ", count = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", 661 CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), 662 index, propCount, (uintptr_t)props, count, (uintptr_t)length, (uintptr_t)params); 663 664 if (context) 665 { 666 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 667 SCOPED_SHARE_CONTEXT_LOCK(context); 668 bool isCallValid = (context->skipValidation() || 669 ValidateGetProgramResourceiv( 670 context, angle::EntryPoint::GLGetProgramResourceiv, programPacked, 671 programInterface, index, propCount, props, count, length, params)); 672 if (isCallValid) 673 { 674 context->getProgramResourceiv(programPacked, programInterface, index, propCount, props, 675 count, length, params); 676 } 677 ANGLE_CAPTURE_GL(GetProgramResourceiv, isCallValid, context, programPacked, 678 programInterface, index, propCount, props, count, length, params); 679 } 680 else 681 { 682 GenerateContextLostErrorOnCurrentGlobalContext(); 683 } 684 } 685 686 void GL_APIENTRY GL_GetTexLevelParameterfv(GLenum target, 687 GLint level, 688 GLenum pname, 689 GLfloat *params) 690 { 691 Context *context = GetValidGlobalContext(); 692 EVENT(context, GLGetTexLevelParameterfv, 693 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", 694 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, 695 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); 696 697 if (context) 698 { 699 TextureTarget targetPacked = PackParam<TextureTarget>(target); 700 SCOPED_SHARE_CONTEXT_LOCK(context); 701 bool isCallValid = 702 (context->skipValidation() || 703 ValidateGetTexLevelParameterfv(context, angle::EntryPoint::GLGetTexLevelParameterfv, 704 targetPacked, level, pname, params)); 705 if (isCallValid) 706 { 707 context->getTexLevelParameterfv(targetPacked, level, pname, params); 708 } 709 ANGLE_CAPTURE_GL(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname, 710 params); 711 } 712 else 713 { 714 GenerateContextLostErrorOnCurrentGlobalContext(); 715 } 716 } 717 718 void GL_APIENTRY GL_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) 719 { 720 Context *context = GetValidGlobalContext(); 721 EVENT(context, GLGetTexLevelParameteriv, 722 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", 723 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, 724 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); 725 726 if (context) 727 { 728 TextureTarget targetPacked = PackParam<TextureTarget>(target); 729 SCOPED_SHARE_CONTEXT_LOCK(context); 730 bool isCallValid = 731 (context->skipValidation() || 732 ValidateGetTexLevelParameteriv(context, angle::EntryPoint::GLGetTexLevelParameteriv, 733 targetPacked, level, pname, params)); 734 if (isCallValid) 735 { 736 context->getTexLevelParameteriv(targetPacked, level, pname, params); 737 } 738 ANGLE_CAPTURE_GL(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname, 739 params); 740 } 741 else 742 { 743 GenerateContextLostErrorOnCurrentGlobalContext(); 744 } 745 } 746 747 GLboolean GL_APIENTRY GL_IsProgramPipeline(GLuint pipeline) 748 { 749 Context *context = GetValidGlobalContext(); 750 EVENT(context, GLIsProgramPipeline, "context = %d, pipeline = %u", CID(context), pipeline); 751 752 GLboolean returnValue; 753 if (context) 754 { 755 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); 756 SCOPED_SHARE_CONTEXT_LOCK(context); 757 bool isCallValid = (context->skipValidation() || 758 ValidateIsProgramPipeline( 759 context, angle::EntryPoint::GLIsProgramPipeline, pipelinePacked)); 760 if (isCallValid) 761 { 762 returnValue = context->isProgramPipeline(pipelinePacked); 763 } 764 else 765 { 766 returnValue = 767 GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipeline, GLboolean>(); 768 } 769 ANGLE_CAPTURE_GL(IsProgramPipeline, isCallValid, context, pipelinePacked, returnValue); 770 } 771 else 772 { 773 GenerateContextLostErrorOnCurrentGlobalContext(); 774 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipeline, GLboolean>(); 775 } 776 return returnValue; 777 } 778 779 void GL_APIENTRY GL_MemoryBarrier(GLbitfield barriers) 780 { 781 Context *context = GetValidGlobalContext(); 782 EVENT(context, GLMemoryBarrier, "context = %d, barriers = %s", CID(context), 783 GLbitfieldToString(GLESEnum::MemoryBarrierMask, barriers).c_str()); 784 785 if (context) 786 { 787 SCOPED_SHARE_CONTEXT_LOCK(context); 788 bool isCallValid = 789 (context->skipValidation() || 790 ValidateMemoryBarrier(context, angle::EntryPoint::GLMemoryBarrier, barriers)); 791 if (isCallValid) 792 { 793 context->memoryBarrier(barriers); 794 } 795 ANGLE_CAPTURE_GL(MemoryBarrier, isCallValid, context, barriers); 796 } 797 else 798 { 799 GenerateContextLostErrorOnCurrentGlobalContext(); 800 } 801 } 802 803 void GL_APIENTRY GL_MemoryBarrierByRegion(GLbitfield barriers) 804 { 805 Context *context = GetValidGlobalContext(); 806 EVENT(context, GLMemoryBarrierByRegion, "context = %d, barriers = %s", CID(context), 807 GLbitfieldToString(GLESEnum::MemoryBarrierMask, barriers).c_str()); 808 809 if (context) 810 { 811 SCOPED_SHARE_CONTEXT_LOCK(context); 812 bool isCallValid = (context->skipValidation() || 813 ValidateMemoryBarrierByRegion( 814 context, angle::EntryPoint::GLMemoryBarrierByRegion, barriers)); 815 if (isCallValid) 816 { 817 context->memoryBarrierByRegion(barriers); 818 } 819 ANGLE_CAPTURE_GL(MemoryBarrierByRegion, isCallValid, context, barriers); 820 } 821 else 822 { 823 GenerateContextLostErrorOnCurrentGlobalContext(); 824 } 825 } 826 827 void GL_APIENTRY GL_ProgramUniform1f(GLuint program, GLint location, GLfloat v0) 828 { 829 Context *context = GetValidGlobalContext(); 830 EVENT(context, GLProgramUniform1f, "context = %d, program = %u, location = %d, v0 = %f", 831 CID(context), program, location, v0); 832 833 if (context) 834 { 835 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 836 UniformLocation locationPacked = PackParam<UniformLocation>(location); 837 SCOPED_SHARE_CONTEXT_LOCK(context); 838 bool isCallValid = (context->skipValidation() || 839 ValidateProgramUniform1f(context, angle::EntryPoint::GLProgramUniform1f, 840 programPacked, locationPacked, v0)); 841 if (isCallValid) 842 { 843 context->programUniform1f(programPacked, locationPacked, v0); 844 } 845 ANGLE_CAPTURE_GL(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0); 846 } 847 else 848 { 849 GenerateContextLostErrorOnCurrentGlobalContext(); 850 } 851 } 852 853 void GL_APIENTRY GL_ProgramUniform1fv(GLuint program, 854 GLint location, 855 GLsizei count, 856 const GLfloat *value) 857 { 858 Context *context = GetValidGlobalContext(); 859 EVENT(context, GLProgramUniform1fv, 860 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 861 CID(context), program, location, count, (uintptr_t)value); 862 863 if (context) 864 { 865 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 866 UniformLocation locationPacked = PackParam<UniformLocation>(location); 867 SCOPED_SHARE_CONTEXT_LOCK(context); 868 bool isCallValid = 869 (context->skipValidation() || 870 ValidateProgramUniform1fv(context, angle::EntryPoint::GLProgramUniform1fv, 871 programPacked, locationPacked, count, value)); 872 if (isCallValid) 873 { 874 context->programUniform1fv(programPacked, locationPacked, count, value); 875 } 876 ANGLE_CAPTURE_GL(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, 877 count, value); 878 } 879 else 880 { 881 GenerateContextLostErrorOnCurrentGlobalContext(); 882 } 883 } 884 885 void GL_APIENTRY GL_ProgramUniform1i(GLuint program, GLint location, GLint v0) 886 { 887 Context *context = GetValidGlobalContext(); 888 EVENT(context, GLProgramUniform1i, "context = %d, program = %u, location = %d, v0 = %d", 889 CID(context), program, location, v0); 890 891 if (context) 892 { 893 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 894 UniformLocation locationPacked = PackParam<UniformLocation>(location); 895 SCOPED_SHARE_CONTEXT_LOCK(context); 896 bool isCallValid = (context->skipValidation() || 897 ValidateProgramUniform1i(context, angle::EntryPoint::GLProgramUniform1i, 898 programPacked, locationPacked, v0)); 899 if (isCallValid) 900 { 901 context->programUniform1i(programPacked, locationPacked, v0); 902 } 903 ANGLE_CAPTURE_GL(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0); 904 } 905 else 906 { 907 GenerateContextLostErrorOnCurrentGlobalContext(); 908 } 909 } 910 911 void GL_APIENTRY GL_ProgramUniform1iv(GLuint program, 912 GLint location, 913 GLsizei count, 914 const GLint *value) 915 { 916 Context *context = GetValidGlobalContext(); 917 EVENT(context, GLProgramUniform1iv, 918 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 919 CID(context), program, location, count, (uintptr_t)value); 920 921 if (context) 922 { 923 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 924 UniformLocation locationPacked = PackParam<UniformLocation>(location); 925 SCOPED_SHARE_CONTEXT_LOCK(context); 926 bool isCallValid = 927 (context->skipValidation() || 928 ValidateProgramUniform1iv(context, angle::EntryPoint::GLProgramUniform1iv, 929 programPacked, locationPacked, count, value)); 930 if (isCallValid) 931 { 932 context->programUniform1iv(programPacked, locationPacked, count, value); 933 } 934 ANGLE_CAPTURE_GL(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, 935 count, value); 936 } 937 else 938 { 939 GenerateContextLostErrorOnCurrentGlobalContext(); 940 } 941 } 942 943 void GL_APIENTRY GL_ProgramUniform1ui(GLuint program, GLint location, GLuint v0) 944 { 945 Context *context = GetValidGlobalContext(); 946 EVENT(context, GLProgramUniform1ui, "context = %d, program = %u, location = %d, v0 = %u", 947 CID(context), program, location, v0); 948 949 if (context) 950 { 951 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 952 UniformLocation locationPacked = PackParam<UniformLocation>(location); 953 SCOPED_SHARE_CONTEXT_LOCK(context); 954 bool isCallValid = 955 (context->skipValidation() || 956 ValidateProgramUniform1ui(context, angle::EntryPoint::GLProgramUniform1ui, 957 programPacked, locationPacked, v0)); 958 if (isCallValid) 959 { 960 context->programUniform1ui(programPacked, locationPacked, v0); 961 } 962 ANGLE_CAPTURE_GL(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, 963 v0); 964 } 965 else 966 { 967 GenerateContextLostErrorOnCurrentGlobalContext(); 968 } 969 } 970 971 void GL_APIENTRY GL_ProgramUniform1uiv(GLuint program, 972 GLint location, 973 GLsizei count, 974 const GLuint *value) 975 { 976 Context *context = GetValidGlobalContext(); 977 EVENT(context, GLProgramUniform1uiv, 978 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 979 CID(context), program, location, count, (uintptr_t)value); 980 981 if (context) 982 { 983 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 984 UniformLocation locationPacked = PackParam<UniformLocation>(location); 985 SCOPED_SHARE_CONTEXT_LOCK(context); 986 bool isCallValid = 987 (context->skipValidation() || 988 ValidateProgramUniform1uiv(context, angle::EntryPoint::GLProgramUniform1uiv, 989 programPacked, locationPacked, count, value)); 990 if (isCallValid) 991 { 992 context->programUniform1uiv(programPacked, locationPacked, count, value); 993 } 994 ANGLE_CAPTURE_GL(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked, 995 count, value); 996 } 997 else 998 { 999 GenerateContextLostErrorOnCurrentGlobalContext(); 1000 } 1001 } 1002 1003 void GL_APIENTRY GL_ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1) 1004 { 1005 Context *context = GetValidGlobalContext(); 1006 EVENT(context, GLProgramUniform2f, 1007 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f", CID(context), program, 1008 location, v0, v1); 1009 1010 if (context) 1011 { 1012 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1013 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1014 SCOPED_SHARE_CONTEXT_LOCK(context); 1015 bool isCallValid = (context->skipValidation() || 1016 ValidateProgramUniform2f(context, angle::EntryPoint::GLProgramUniform2f, 1017 programPacked, locationPacked, v0, v1)); 1018 if (isCallValid) 1019 { 1020 context->programUniform2f(programPacked, locationPacked, v0, v1); 1021 } 1022 ANGLE_CAPTURE_GL(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0, 1023 v1); 1024 } 1025 else 1026 { 1027 GenerateContextLostErrorOnCurrentGlobalContext(); 1028 } 1029 } 1030 1031 void GL_APIENTRY GL_ProgramUniform2fv(GLuint program, 1032 GLint location, 1033 GLsizei count, 1034 const GLfloat *value) 1035 { 1036 Context *context = GetValidGlobalContext(); 1037 EVENT(context, GLProgramUniform2fv, 1038 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1039 CID(context), program, location, count, (uintptr_t)value); 1040 1041 if (context) 1042 { 1043 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1044 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1045 SCOPED_SHARE_CONTEXT_LOCK(context); 1046 bool isCallValid = 1047 (context->skipValidation() || 1048 ValidateProgramUniform2fv(context, angle::EntryPoint::GLProgramUniform2fv, 1049 programPacked, locationPacked, count, value)); 1050 if (isCallValid) 1051 { 1052 context->programUniform2fv(programPacked, locationPacked, count, value); 1053 } 1054 ANGLE_CAPTURE_GL(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, 1055 count, value); 1056 } 1057 else 1058 { 1059 GenerateContextLostErrorOnCurrentGlobalContext(); 1060 } 1061 } 1062 1063 void GL_APIENTRY GL_ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1) 1064 { 1065 Context *context = GetValidGlobalContext(); 1066 EVENT(context, GLProgramUniform2i, 1067 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d", CID(context), program, 1068 location, v0, v1); 1069 1070 if (context) 1071 { 1072 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1073 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1074 SCOPED_SHARE_CONTEXT_LOCK(context); 1075 bool isCallValid = (context->skipValidation() || 1076 ValidateProgramUniform2i(context, angle::EntryPoint::GLProgramUniform2i, 1077 programPacked, locationPacked, v0, v1)); 1078 if (isCallValid) 1079 { 1080 context->programUniform2i(programPacked, locationPacked, v0, v1); 1081 } 1082 ANGLE_CAPTURE_GL(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0, 1083 v1); 1084 } 1085 else 1086 { 1087 GenerateContextLostErrorOnCurrentGlobalContext(); 1088 } 1089 } 1090 1091 void GL_APIENTRY GL_ProgramUniform2iv(GLuint program, 1092 GLint location, 1093 GLsizei count, 1094 const GLint *value) 1095 { 1096 Context *context = GetValidGlobalContext(); 1097 EVENT(context, GLProgramUniform2iv, 1098 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1099 CID(context), program, location, count, (uintptr_t)value); 1100 1101 if (context) 1102 { 1103 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1104 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1105 SCOPED_SHARE_CONTEXT_LOCK(context); 1106 bool isCallValid = 1107 (context->skipValidation() || 1108 ValidateProgramUniform2iv(context, angle::EntryPoint::GLProgramUniform2iv, 1109 programPacked, locationPacked, count, value)); 1110 if (isCallValid) 1111 { 1112 context->programUniform2iv(programPacked, locationPacked, count, value); 1113 } 1114 ANGLE_CAPTURE_GL(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, 1115 count, value); 1116 } 1117 else 1118 { 1119 GenerateContextLostErrorOnCurrentGlobalContext(); 1120 } 1121 } 1122 1123 void GL_APIENTRY GL_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1) 1124 { 1125 Context *context = GetValidGlobalContext(); 1126 EVENT(context, GLProgramUniform2ui, 1127 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u", CID(context), program, 1128 location, v0, v1); 1129 1130 if (context) 1131 { 1132 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1133 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1134 SCOPED_SHARE_CONTEXT_LOCK(context); 1135 bool isCallValid = 1136 (context->skipValidation() || 1137 ValidateProgramUniform2ui(context, angle::EntryPoint::GLProgramUniform2ui, 1138 programPacked, locationPacked, v0, v1)); 1139 if (isCallValid) 1140 { 1141 context->programUniform2ui(programPacked, locationPacked, v0, v1); 1142 } 1143 ANGLE_CAPTURE_GL(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0, 1144 v1); 1145 } 1146 else 1147 { 1148 GenerateContextLostErrorOnCurrentGlobalContext(); 1149 } 1150 } 1151 1152 void GL_APIENTRY GL_ProgramUniform2uiv(GLuint program, 1153 GLint location, 1154 GLsizei count, 1155 const GLuint *value) 1156 { 1157 Context *context = GetValidGlobalContext(); 1158 EVENT(context, GLProgramUniform2uiv, 1159 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1160 CID(context), program, location, count, (uintptr_t)value); 1161 1162 if (context) 1163 { 1164 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1165 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1166 SCOPED_SHARE_CONTEXT_LOCK(context); 1167 bool isCallValid = 1168 (context->skipValidation() || 1169 ValidateProgramUniform2uiv(context, angle::EntryPoint::GLProgramUniform2uiv, 1170 programPacked, locationPacked, count, value)); 1171 if (isCallValid) 1172 { 1173 context->programUniform2uiv(programPacked, locationPacked, count, value); 1174 } 1175 ANGLE_CAPTURE_GL(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked, 1176 count, value); 1177 } 1178 else 1179 { 1180 GenerateContextLostErrorOnCurrentGlobalContext(); 1181 } 1182 } 1183 1184 void GL_APIENTRY 1185 GL_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) 1186 { 1187 Context *context = GetValidGlobalContext(); 1188 EVENT(context, GLProgramUniform3f, 1189 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f", CID(context), 1190 program, location, v0, v1, v2); 1191 1192 if (context) 1193 { 1194 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1195 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1196 SCOPED_SHARE_CONTEXT_LOCK(context); 1197 bool isCallValid = (context->skipValidation() || 1198 ValidateProgramUniform3f(context, angle::EntryPoint::GLProgramUniform3f, 1199 programPacked, locationPacked, v0, v1, v2)); 1200 if (isCallValid) 1201 { 1202 context->programUniform3f(programPacked, locationPacked, v0, v1, v2); 1203 } 1204 ANGLE_CAPTURE_GL(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, 1205 v1, v2); 1206 } 1207 else 1208 { 1209 GenerateContextLostErrorOnCurrentGlobalContext(); 1210 } 1211 } 1212 1213 void GL_APIENTRY GL_ProgramUniform3fv(GLuint program, 1214 GLint location, 1215 GLsizei count, 1216 const GLfloat *value) 1217 { 1218 Context *context = GetValidGlobalContext(); 1219 EVENT(context, GLProgramUniform3fv, 1220 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1221 CID(context), program, location, count, (uintptr_t)value); 1222 1223 if (context) 1224 { 1225 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1226 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1227 SCOPED_SHARE_CONTEXT_LOCK(context); 1228 bool isCallValid = 1229 (context->skipValidation() || 1230 ValidateProgramUniform3fv(context, angle::EntryPoint::GLProgramUniform3fv, 1231 programPacked, locationPacked, count, value)); 1232 if (isCallValid) 1233 { 1234 context->programUniform3fv(programPacked, locationPacked, count, value); 1235 } 1236 ANGLE_CAPTURE_GL(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, 1237 count, value); 1238 } 1239 else 1240 { 1241 GenerateContextLostErrorOnCurrentGlobalContext(); 1242 } 1243 } 1244 1245 void GL_APIENTRY GL_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) 1246 { 1247 Context *context = GetValidGlobalContext(); 1248 EVENT(context, GLProgramUniform3i, 1249 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d", CID(context), 1250 program, location, v0, v1, v2); 1251 1252 if (context) 1253 { 1254 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1255 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1256 SCOPED_SHARE_CONTEXT_LOCK(context); 1257 bool isCallValid = (context->skipValidation() || 1258 ValidateProgramUniform3i(context, angle::EntryPoint::GLProgramUniform3i, 1259 programPacked, locationPacked, v0, v1, v2)); 1260 if (isCallValid) 1261 { 1262 context->programUniform3i(programPacked, locationPacked, v0, v1, v2); 1263 } 1264 ANGLE_CAPTURE_GL(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, 1265 v1, v2); 1266 } 1267 else 1268 { 1269 GenerateContextLostErrorOnCurrentGlobalContext(); 1270 } 1271 } 1272 1273 void GL_APIENTRY GL_ProgramUniform3iv(GLuint program, 1274 GLint location, 1275 GLsizei count, 1276 const GLint *value) 1277 { 1278 Context *context = GetValidGlobalContext(); 1279 EVENT(context, GLProgramUniform3iv, 1280 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1281 CID(context), program, location, count, (uintptr_t)value); 1282 1283 if (context) 1284 { 1285 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1286 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1287 SCOPED_SHARE_CONTEXT_LOCK(context); 1288 bool isCallValid = 1289 (context->skipValidation() || 1290 ValidateProgramUniform3iv(context, angle::EntryPoint::GLProgramUniform3iv, 1291 programPacked, locationPacked, count, value)); 1292 if (isCallValid) 1293 { 1294 context->programUniform3iv(programPacked, locationPacked, count, value); 1295 } 1296 ANGLE_CAPTURE_GL(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, 1297 count, value); 1298 } 1299 else 1300 { 1301 GenerateContextLostErrorOnCurrentGlobalContext(); 1302 } 1303 } 1304 1305 void GL_APIENTRY 1306 GL_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) 1307 { 1308 Context *context = GetValidGlobalContext(); 1309 EVENT(context, GLProgramUniform3ui, 1310 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u", CID(context), 1311 program, location, v0, v1, v2); 1312 1313 if (context) 1314 { 1315 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1316 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1317 SCOPED_SHARE_CONTEXT_LOCK(context); 1318 bool isCallValid = 1319 (context->skipValidation() || 1320 ValidateProgramUniform3ui(context, angle::EntryPoint::GLProgramUniform3ui, 1321 programPacked, locationPacked, v0, v1, v2)); 1322 if (isCallValid) 1323 { 1324 context->programUniform3ui(programPacked, locationPacked, v0, v1, v2); 1325 } 1326 ANGLE_CAPTURE_GL(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0, 1327 v1, v2); 1328 } 1329 else 1330 { 1331 GenerateContextLostErrorOnCurrentGlobalContext(); 1332 } 1333 } 1334 1335 void GL_APIENTRY GL_ProgramUniform3uiv(GLuint program, 1336 GLint location, 1337 GLsizei count, 1338 const GLuint *value) 1339 { 1340 Context *context = GetValidGlobalContext(); 1341 EVENT(context, GLProgramUniform3uiv, 1342 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1343 CID(context), program, location, count, (uintptr_t)value); 1344 1345 if (context) 1346 { 1347 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1348 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1349 SCOPED_SHARE_CONTEXT_LOCK(context); 1350 bool isCallValid = 1351 (context->skipValidation() || 1352 ValidateProgramUniform3uiv(context, angle::EntryPoint::GLProgramUniform3uiv, 1353 programPacked, locationPacked, count, value)); 1354 if (isCallValid) 1355 { 1356 context->programUniform3uiv(programPacked, locationPacked, count, value); 1357 } 1358 ANGLE_CAPTURE_GL(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked, 1359 count, value); 1360 } 1361 else 1362 { 1363 GenerateContextLostErrorOnCurrentGlobalContext(); 1364 } 1365 } 1366 1367 void GL_APIENTRY 1368 GL_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) 1369 { 1370 Context *context = GetValidGlobalContext(); 1371 EVENT(context, GLProgramUniform4f, 1372 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f", 1373 CID(context), program, location, v0, v1, v2, v3); 1374 1375 if (context) 1376 { 1377 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1378 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1379 SCOPED_SHARE_CONTEXT_LOCK(context); 1380 bool isCallValid = 1381 (context->skipValidation() || 1382 ValidateProgramUniform4f(context, angle::EntryPoint::GLProgramUniform4f, programPacked, 1383 locationPacked, v0, v1, v2, v3)); 1384 if (isCallValid) 1385 { 1386 context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3); 1387 } 1388 ANGLE_CAPTURE_GL(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, 1389 v1, v2, v3); 1390 } 1391 else 1392 { 1393 GenerateContextLostErrorOnCurrentGlobalContext(); 1394 } 1395 } 1396 1397 void GL_APIENTRY GL_ProgramUniform4fv(GLuint program, 1398 GLint location, 1399 GLsizei count, 1400 const GLfloat *value) 1401 { 1402 Context *context = GetValidGlobalContext(); 1403 EVENT(context, GLProgramUniform4fv, 1404 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1405 CID(context), program, location, count, (uintptr_t)value); 1406 1407 if (context) 1408 { 1409 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1410 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1411 SCOPED_SHARE_CONTEXT_LOCK(context); 1412 bool isCallValid = 1413 (context->skipValidation() || 1414 ValidateProgramUniform4fv(context, angle::EntryPoint::GLProgramUniform4fv, 1415 programPacked, locationPacked, count, value)); 1416 if (isCallValid) 1417 { 1418 context->programUniform4fv(programPacked, locationPacked, count, value); 1419 } 1420 ANGLE_CAPTURE_GL(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, 1421 count, value); 1422 } 1423 else 1424 { 1425 GenerateContextLostErrorOnCurrentGlobalContext(); 1426 } 1427 } 1428 1429 void GL_APIENTRY 1430 GL_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) 1431 { 1432 Context *context = GetValidGlobalContext(); 1433 EVENT(context, GLProgramUniform4i, 1434 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d", 1435 CID(context), program, location, v0, v1, v2, v3); 1436 1437 if (context) 1438 { 1439 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1440 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1441 SCOPED_SHARE_CONTEXT_LOCK(context); 1442 bool isCallValid = 1443 (context->skipValidation() || 1444 ValidateProgramUniform4i(context, angle::EntryPoint::GLProgramUniform4i, programPacked, 1445 locationPacked, v0, v1, v2, v3)); 1446 if (isCallValid) 1447 { 1448 context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3); 1449 } 1450 ANGLE_CAPTURE_GL(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, 1451 v1, v2, v3); 1452 } 1453 else 1454 { 1455 GenerateContextLostErrorOnCurrentGlobalContext(); 1456 } 1457 } 1458 1459 void GL_APIENTRY GL_ProgramUniform4iv(GLuint program, 1460 GLint location, 1461 GLsizei count, 1462 const GLint *value) 1463 { 1464 Context *context = GetValidGlobalContext(); 1465 EVENT(context, GLProgramUniform4iv, 1466 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1467 CID(context), program, location, count, (uintptr_t)value); 1468 1469 if (context) 1470 { 1471 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1472 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1473 SCOPED_SHARE_CONTEXT_LOCK(context); 1474 bool isCallValid = 1475 (context->skipValidation() || 1476 ValidateProgramUniform4iv(context, angle::EntryPoint::GLProgramUniform4iv, 1477 programPacked, locationPacked, count, value)); 1478 if (isCallValid) 1479 { 1480 context->programUniform4iv(programPacked, locationPacked, count, value); 1481 } 1482 ANGLE_CAPTURE_GL(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, 1483 count, value); 1484 } 1485 else 1486 { 1487 GenerateContextLostErrorOnCurrentGlobalContext(); 1488 } 1489 } 1490 1491 void GL_APIENTRY 1492 GL_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) 1493 { 1494 Context *context = GetValidGlobalContext(); 1495 EVENT(context, GLProgramUniform4ui, 1496 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u", 1497 CID(context), program, location, v0, v1, v2, v3); 1498 1499 if (context) 1500 { 1501 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1502 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1503 SCOPED_SHARE_CONTEXT_LOCK(context); 1504 bool isCallValid = 1505 (context->skipValidation() || 1506 ValidateProgramUniform4ui(context, angle::EntryPoint::GLProgramUniform4ui, 1507 programPacked, locationPacked, v0, v1, v2, v3)); 1508 if (isCallValid) 1509 { 1510 context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3); 1511 } 1512 ANGLE_CAPTURE_GL(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0, 1513 v1, v2, v3); 1514 } 1515 else 1516 { 1517 GenerateContextLostErrorOnCurrentGlobalContext(); 1518 } 1519 } 1520 1521 void GL_APIENTRY GL_ProgramUniform4uiv(GLuint program, 1522 GLint location, 1523 GLsizei count, 1524 const GLuint *value) 1525 { 1526 Context *context = GetValidGlobalContext(); 1527 EVENT(context, GLProgramUniform4uiv, 1528 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", 1529 CID(context), program, location, count, (uintptr_t)value); 1530 1531 if (context) 1532 { 1533 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1534 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1535 SCOPED_SHARE_CONTEXT_LOCK(context); 1536 bool isCallValid = 1537 (context->skipValidation() || 1538 ValidateProgramUniform4uiv(context, angle::EntryPoint::GLProgramUniform4uiv, 1539 programPacked, locationPacked, count, value)); 1540 if (isCallValid) 1541 { 1542 context->programUniform4uiv(programPacked, locationPacked, count, value); 1543 } 1544 ANGLE_CAPTURE_GL(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked, 1545 count, value); 1546 } 1547 else 1548 { 1549 GenerateContextLostErrorOnCurrentGlobalContext(); 1550 } 1551 } 1552 1553 void GL_APIENTRY GL_ProgramUniformMatrix2fv(GLuint program, 1554 GLint location, 1555 GLsizei count, 1556 GLboolean transpose, 1557 const GLfloat *value) 1558 { 1559 Context *context = GetValidGlobalContext(); 1560 EVENT(context, GLProgramUniformMatrix2fv, 1561 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1562 "0x%016" PRIxPTR "", 1563 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1564 1565 if (context) 1566 { 1567 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1568 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1569 SCOPED_SHARE_CONTEXT_LOCK(context); 1570 bool isCallValid = (context->skipValidation() || 1571 ValidateProgramUniformMatrix2fv( 1572 context, angle::EntryPoint::GLProgramUniformMatrix2fv, 1573 programPacked, locationPacked, count, transpose, value)); 1574 if (isCallValid) 1575 { 1576 context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose, 1577 value); 1578 } 1579 ANGLE_CAPTURE_GL(ProgramUniformMatrix2fv, isCallValid, context, programPacked, 1580 locationPacked, count, transpose, value); 1581 } 1582 else 1583 { 1584 GenerateContextLostErrorOnCurrentGlobalContext(); 1585 } 1586 } 1587 1588 void GL_APIENTRY GL_ProgramUniformMatrix2x3fv(GLuint program, 1589 GLint location, 1590 GLsizei count, 1591 GLboolean transpose, 1592 const GLfloat *value) 1593 { 1594 Context *context = GetValidGlobalContext(); 1595 EVENT(context, GLProgramUniformMatrix2x3fv, 1596 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1597 "0x%016" PRIxPTR "", 1598 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1599 1600 if (context) 1601 { 1602 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1603 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1604 SCOPED_SHARE_CONTEXT_LOCK(context); 1605 bool isCallValid = (context->skipValidation() || 1606 ValidateProgramUniformMatrix2x3fv( 1607 context, angle::EntryPoint::GLProgramUniformMatrix2x3fv, 1608 programPacked, locationPacked, count, transpose, value)); 1609 if (isCallValid) 1610 { 1611 context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose, 1612 value); 1613 } 1614 ANGLE_CAPTURE_GL(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked, 1615 locationPacked, count, transpose, value); 1616 } 1617 else 1618 { 1619 GenerateContextLostErrorOnCurrentGlobalContext(); 1620 } 1621 } 1622 1623 void GL_APIENTRY GL_ProgramUniformMatrix2x4fv(GLuint program, 1624 GLint location, 1625 GLsizei count, 1626 GLboolean transpose, 1627 const GLfloat *value) 1628 { 1629 Context *context = GetValidGlobalContext(); 1630 EVENT(context, GLProgramUniformMatrix2x4fv, 1631 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1632 "0x%016" PRIxPTR "", 1633 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1634 1635 if (context) 1636 { 1637 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1638 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1639 SCOPED_SHARE_CONTEXT_LOCK(context); 1640 bool isCallValid = (context->skipValidation() || 1641 ValidateProgramUniformMatrix2x4fv( 1642 context, angle::EntryPoint::GLProgramUniformMatrix2x4fv, 1643 programPacked, locationPacked, count, transpose, value)); 1644 if (isCallValid) 1645 { 1646 context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose, 1647 value); 1648 } 1649 ANGLE_CAPTURE_GL(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked, 1650 locationPacked, count, transpose, value); 1651 } 1652 else 1653 { 1654 GenerateContextLostErrorOnCurrentGlobalContext(); 1655 } 1656 } 1657 1658 void GL_APIENTRY GL_ProgramUniformMatrix3fv(GLuint program, 1659 GLint location, 1660 GLsizei count, 1661 GLboolean transpose, 1662 const GLfloat *value) 1663 { 1664 Context *context = GetValidGlobalContext(); 1665 EVENT(context, GLProgramUniformMatrix3fv, 1666 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1667 "0x%016" PRIxPTR "", 1668 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1669 1670 if (context) 1671 { 1672 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1673 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1674 SCOPED_SHARE_CONTEXT_LOCK(context); 1675 bool isCallValid = (context->skipValidation() || 1676 ValidateProgramUniformMatrix3fv( 1677 context, angle::EntryPoint::GLProgramUniformMatrix3fv, 1678 programPacked, locationPacked, count, transpose, value)); 1679 if (isCallValid) 1680 { 1681 context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose, 1682 value); 1683 } 1684 ANGLE_CAPTURE_GL(ProgramUniformMatrix3fv, isCallValid, context, programPacked, 1685 locationPacked, count, transpose, value); 1686 } 1687 else 1688 { 1689 GenerateContextLostErrorOnCurrentGlobalContext(); 1690 } 1691 } 1692 1693 void GL_APIENTRY GL_ProgramUniformMatrix3x2fv(GLuint program, 1694 GLint location, 1695 GLsizei count, 1696 GLboolean transpose, 1697 const GLfloat *value) 1698 { 1699 Context *context = GetValidGlobalContext(); 1700 EVENT(context, GLProgramUniformMatrix3x2fv, 1701 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1702 "0x%016" PRIxPTR "", 1703 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1704 1705 if (context) 1706 { 1707 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1708 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1709 SCOPED_SHARE_CONTEXT_LOCK(context); 1710 bool isCallValid = (context->skipValidation() || 1711 ValidateProgramUniformMatrix3x2fv( 1712 context, angle::EntryPoint::GLProgramUniformMatrix3x2fv, 1713 programPacked, locationPacked, count, transpose, value)); 1714 if (isCallValid) 1715 { 1716 context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose, 1717 value); 1718 } 1719 ANGLE_CAPTURE_GL(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked, 1720 locationPacked, count, transpose, value); 1721 } 1722 else 1723 { 1724 GenerateContextLostErrorOnCurrentGlobalContext(); 1725 } 1726 } 1727 1728 void GL_APIENTRY GL_ProgramUniformMatrix3x4fv(GLuint program, 1729 GLint location, 1730 GLsizei count, 1731 GLboolean transpose, 1732 const GLfloat *value) 1733 { 1734 Context *context = GetValidGlobalContext(); 1735 EVENT(context, GLProgramUniformMatrix3x4fv, 1736 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1737 "0x%016" PRIxPTR "", 1738 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1739 1740 if (context) 1741 { 1742 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1743 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1744 SCOPED_SHARE_CONTEXT_LOCK(context); 1745 bool isCallValid = (context->skipValidation() || 1746 ValidateProgramUniformMatrix3x4fv( 1747 context, angle::EntryPoint::GLProgramUniformMatrix3x4fv, 1748 programPacked, locationPacked, count, transpose, value)); 1749 if (isCallValid) 1750 { 1751 context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose, 1752 value); 1753 } 1754 ANGLE_CAPTURE_GL(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked, 1755 locationPacked, count, transpose, value); 1756 } 1757 else 1758 { 1759 GenerateContextLostErrorOnCurrentGlobalContext(); 1760 } 1761 } 1762 1763 void GL_APIENTRY GL_ProgramUniformMatrix4fv(GLuint program, 1764 GLint location, 1765 GLsizei count, 1766 GLboolean transpose, 1767 const GLfloat *value) 1768 { 1769 Context *context = GetValidGlobalContext(); 1770 EVENT(context, GLProgramUniformMatrix4fv, 1771 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1772 "0x%016" PRIxPTR "", 1773 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1774 1775 if (context) 1776 { 1777 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1778 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1779 SCOPED_SHARE_CONTEXT_LOCK(context); 1780 bool isCallValid = (context->skipValidation() || 1781 ValidateProgramUniformMatrix4fv( 1782 context, angle::EntryPoint::GLProgramUniformMatrix4fv, 1783 programPacked, locationPacked, count, transpose, value)); 1784 if (isCallValid) 1785 { 1786 context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose, 1787 value); 1788 } 1789 ANGLE_CAPTURE_GL(ProgramUniformMatrix4fv, isCallValid, context, programPacked, 1790 locationPacked, count, transpose, value); 1791 } 1792 else 1793 { 1794 GenerateContextLostErrorOnCurrentGlobalContext(); 1795 } 1796 } 1797 1798 void GL_APIENTRY GL_ProgramUniformMatrix4x2fv(GLuint program, 1799 GLint location, 1800 GLsizei count, 1801 GLboolean transpose, 1802 const GLfloat *value) 1803 { 1804 Context *context = GetValidGlobalContext(); 1805 EVENT(context, GLProgramUniformMatrix4x2fv, 1806 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1807 "0x%016" PRIxPTR "", 1808 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1809 1810 if (context) 1811 { 1812 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1813 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1814 SCOPED_SHARE_CONTEXT_LOCK(context); 1815 bool isCallValid = (context->skipValidation() || 1816 ValidateProgramUniformMatrix4x2fv( 1817 context, angle::EntryPoint::GLProgramUniformMatrix4x2fv, 1818 programPacked, locationPacked, count, transpose, value)); 1819 if (isCallValid) 1820 { 1821 context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose, 1822 value); 1823 } 1824 ANGLE_CAPTURE_GL(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked, 1825 locationPacked, count, transpose, value); 1826 } 1827 else 1828 { 1829 GenerateContextLostErrorOnCurrentGlobalContext(); 1830 } 1831 } 1832 1833 void GL_APIENTRY GL_ProgramUniformMatrix4x3fv(GLuint program, 1834 GLint location, 1835 GLsizei count, 1836 GLboolean transpose, 1837 const GLfloat *value) 1838 { 1839 Context *context = GetValidGlobalContext(); 1840 EVENT(context, GLProgramUniformMatrix4x3fv, 1841 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " 1842 "0x%016" PRIxPTR "", 1843 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); 1844 1845 if (context) 1846 { 1847 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1848 UniformLocation locationPacked = PackParam<UniformLocation>(location); 1849 SCOPED_SHARE_CONTEXT_LOCK(context); 1850 bool isCallValid = (context->skipValidation() || 1851 ValidateProgramUniformMatrix4x3fv( 1852 context, angle::EntryPoint::GLProgramUniformMatrix4x3fv, 1853 programPacked, locationPacked, count, transpose, value)); 1854 if (isCallValid) 1855 { 1856 context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose, 1857 value); 1858 } 1859 ANGLE_CAPTURE_GL(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked, 1860 locationPacked, count, transpose, value); 1861 } 1862 else 1863 { 1864 GenerateContextLostErrorOnCurrentGlobalContext(); 1865 } 1866 } 1867 1868 void GL_APIENTRY GL_SampleMaski(GLuint maskNumber, GLbitfield mask) 1869 { 1870 Context *context = GetValidGlobalContext(); 1871 EVENT(context, GLSampleMaski, "context = %d, maskNumber = %u, mask = %s", CID(context), 1872 maskNumber, GLbitfieldToString(GLESEnum::AllEnums, mask).c_str()); 1873 1874 if (context) 1875 { 1876 SCOPED_SHARE_CONTEXT_LOCK(context); 1877 bool isCallValid = 1878 (context->skipValidation() || 1879 ValidateSampleMaski(context, angle::EntryPoint::GLSampleMaski, maskNumber, mask)); 1880 if (isCallValid) 1881 { 1882 context->sampleMaski(maskNumber, mask); 1883 } 1884 ANGLE_CAPTURE_GL(SampleMaski, isCallValid, context, maskNumber, mask); 1885 } 1886 else 1887 { 1888 GenerateContextLostErrorOnCurrentGlobalContext(); 1889 } 1890 } 1891 1892 void GL_APIENTRY GL_TexStorage2DMultisample(GLenum target, 1893 GLsizei samples, 1894 GLenum internalformat, 1895 GLsizei width, 1896 GLsizei height, 1897 GLboolean fixedsamplelocations) 1898 { 1899 Context *context = GetValidGlobalContext(); 1900 EVENT(context, GLTexStorage2DMultisample, 1901 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " 1902 "fixedsamplelocations = %s", 1903 CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, 1904 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, 1905 GLbooleanToString(fixedsamplelocations)); 1906 1907 if (context) 1908 { 1909 TextureType targetPacked = PackParam<TextureType>(target); 1910 SCOPED_SHARE_CONTEXT_LOCK(context); 1911 bool isCallValid = (context->skipValidation() || 1912 ValidateTexStorage2DMultisample( 1913 context, angle::EntryPoint::GLTexStorage2DMultisample, targetPacked, 1914 samples, internalformat, width, height, fixedsamplelocations)); 1915 if (isCallValid) 1916 { 1917 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height, 1918 fixedsamplelocations); 1919 } 1920 ANGLE_CAPTURE_GL(TexStorage2DMultisample, isCallValid, context, targetPacked, samples, 1921 internalformat, width, height, fixedsamplelocations); 1922 } 1923 else 1924 { 1925 GenerateContextLostErrorOnCurrentGlobalContext(); 1926 } 1927 } 1928 1929 void GL_APIENTRY GL_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) 1930 { 1931 Context *context = GetValidGlobalContext(); 1932 EVENT(context, GLUseProgramStages, "context = %d, pipeline = %u, stages = %s, program = %u", 1933 CID(context), pipeline, GLbitfieldToString(GLESEnum::UseProgramStageMask, stages).c_str(), 1934 program); 1935 1936 if (context) 1937 { 1938 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); 1939 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); 1940 SCOPED_SHARE_CONTEXT_LOCK(context); 1941 bool isCallValid = (context->skipValidation() || 1942 ValidateUseProgramStages(context, angle::EntryPoint::GLUseProgramStages, 1943 pipelinePacked, stages, programPacked)); 1944 if (isCallValid) 1945 { 1946 context->useProgramStages(pipelinePacked, stages, programPacked); 1947 } 1948 ANGLE_CAPTURE_GL(UseProgramStages, isCallValid, context, pipelinePacked, stages, 1949 programPacked); 1950 } 1951 else 1952 { 1953 GenerateContextLostErrorOnCurrentGlobalContext(); 1954 } 1955 } 1956 1957 void GL_APIENTRY GL_ValidateProgramPipeline(GLuint pipeline) 1958 { 1959 Context *context = GetValidGlobalContext(); 1960 EVENT(context, GLValidateProgramPipeline, "context = %d, pipeline = %u", CID(context), 1961 pipeline); 1962 1963 if (context) 1964 { 1965 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); 1966 SCOPED_SHARE_CONTEXT_LOCK(context); 1967 bool isCallValid = 1968 (context->skipValidation() || 1969 ValidateValidateProgramPipeline(context, angle::EntryPoint::GLValidateProgramPipeline, 1970 pipelinePacked)); 1971 if (isCallValid) 1972 { 1973 context->validateProgramPipeline(pipelinePacked); 1974 } 1975 ANGLE_CAPTURE_GL(ValidateProgramPipeline, isCallValid, context, pipelinePacked); 1976 } 1977 else 1978 { 1979 GenerateContextLostErrorOnCurrentGlobalContext(); 1980 } 1981 } 1982 1983 void GL_APIENTRY GL_VertexAttribBinding(GLuint attribindex, GLuint bindingindex) 1984 { 1985 Context *context = GetValidGlobalContext(); 1986 EVENT(context, GLVertexAttribBinding, "context = %d, attribindex = %u, bindingindex = %u", 1987 CID(context), attribindex, bindingindex); 1988 1989 if (context) 1990 { 1991 SCOPED_SHARE_CONTEXT_LOCK(context); 1992 bool isCallValid = 1993 (context->skipValidation() || 1994 ValidateVertexAttribBinding(context, angle::EntryPoint::GLVertexAttribBinding, 1995 attribindex, bindingindex)); 1996 if (isCallValid) 1997 { 1998 context->vertexAttribBinding(attribindex, bindingindex); 1999 } 2000 ANGLE_CAPTURE_GL(VertexAttribBinding, isCallValid, context, attribindex, bindingindex); 2001 } 2002 else 2003 { 2004 GenerateContextLostErrorOnCurrentGlobalContext(); 2005 } 2006 } 2007 2008 void GL_APIENTRY GL_VertexAttribFormat(GLuint attribindex, 2009 GLint size, 2010 GLenum type, 2011 GLboolean normalized, 2012 GLuint relativeoffset) 2013 { 2014 Context *context = GetValidGlobalContext(); 2015 EVENT(context, GLVertexAttribFormat, 2016 "context = %d, attribindex = %u, size = %d, type = %s, normalized = %s, relativeoffset = " 2017 "%u", 2018 CID(context), attribindex, size, GLenumToString(GLESEnum::VertexAttribType, type), 2019 GLbooleanToString(normalized), relativeoffset); 2020 2021 if (context) 2022 { 2023 VertexAttribType typePacked = PackParam<VertexAttribType>(type); 2024 SCOPED_SHARE_CONTEXT_LOCK(context); 2025 bool isCallValid = 2026 (context->skipValidation() || 2027 ValidateVertexAttribFormat(context, angle::EntryPoint::GLVertexAttribFormat, 2028 attribindex, size, typePacked, normalized, relativeoffset)); 2029 if (isCallValid) 2030 { 2031 context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset); 2032 } 2033 ANGLE_CAPTURE_GL(VertexAttribFormat, isCallValid, context, attribindex, size, typePacked, 2034 normalized, relativeoffset); 2035 } 2036 else 2037 { 2038 GenerateContextLostErrorOnCurrentGlobalContext(); 2039 } 2040 } 2041 2042 void GL_APIENTRY GL_VertexAttribIFormat(GLuint attribindex, 2043 GLint size, 2044 GLenum type, 2045 GLuint relativeoffset) 2046 { 2047 Context *context = GetValidGlobalContext(); 2048 EVENT(context, GLVertexAttribIFormat, 2049 "context = %d, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), 2050 attribindex, size, GLenumToString(GLESEnum::VertexAttribIType, type), relativeoffset); 2051 2052 if (context) 2053 { 2054 VertexAttribType typePacked = PackParam<VertexAttribType>(type); 2055 SCOPED_SHARE_CONTEXT_LOCK(context); 2056 bool isCallValid = 2057 (context->skipValidation() || 2058 ValidateVertexAttribIFormat(context, angle::EntryPoint::GLVertexAttribIFormat, 2059 attribindex, size, typePacked, relativeoffset)); 2060 if (isCallValid) 2061 { 2062 context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset); 2063 } 2064 ANGLE_CAPTURE_GL(VertexAttribIFormat, isCallValid, context, attribindex, size, typePacked, 2065 relativeoffset); 2066 } 2067 else 2068 { 2069 GenerateContextLostErrorOnCurrentGlobalContext(); 2070 } 2071 } 2072 2073 void GL_APIENTRY GL_VertexBindingDivisor(GLuint bindingindex, GLuint divisor) 2074 { 2075 Context *context = GetValidGlobalContext(); 2076 EVENT(context, GLVertexBindingDivisor, "context = %d, bindingindex = %u, divisor = %u", 2077 CID(context), bindingindex, divisor); 2078 2079 if (context) 2080 { 2081 SCOPED_SHARE_CONTEXT_LOCK(context); 2082 bool isCallValid = 2083 (context->skipValidation() || 2084 ValidateVertexBindingDivisor(context, angle::EntryPoint::GLVertexBindingDivisor, 2085 bindingindex, divisor)); 2086 if (isCallValid) 2087 { 2088 context->vertexBindingDivisor(bindingindex, divisor); 2089 } 2090 ANGLE_CAPTURE_GL(VertexBindingDivisor, isCallValid, context, bindingindex, divisor); 2091 } 2092 else 2093 { 2094 GenerateContextLostErrorOnCurrentGlobalContext(); 2095 } 2096 } 2097 2098 } // extern "C"