kc3-lang/angle/src/libGL/entry_points_gl_4_0_autogen.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2019-10-31 14:33:26
  Hash : e9603921
  Message : Capture/Replay: Correct a few GLenum replay issues. This change refactors the GLenum utils into a non-autogenerated and an autogenerated portion. That makes it easier to modify the non-auto- generated bits to properly output GLenums even when the gl.xml data isn't totally correct. For instance, the "GetPName" group was missing a bunch of queries. Instead of trying to fix the GL we can simply fall back to querying the "Default" group when we return invalid enum. Also corrects a missing "0x" on hex output. Also allows the capture/replay sample to specify the correct binary data directory when testing a replay. Bug: angleproject:3611 Change-Id: I8e4c690b2850bb157a8cde8b057b20603e4b177d Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1891008 Reviewed-by: Cody Northrop <cnorthrop@google.com> Commit-Queue: Jamie Madill <jmadill@chromium.org>

• src/libGL/entry_points_gl_4_0_autogen.cpp

• // GENERATED FILE - DO NOT EDIT.
  // Generated by generate_entry_points.py using data from gl.xml.
  //
  // Copyright 2019 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // entry_points_gl_4_0_autogen.cpp:
  //   Defines the GL 4.0 entry points.
  
  #include "libGL/entry_points_gl_4_0_autogen.h"
  
  #include "libANGLE/Context.h"
  #include "libANGLE/Context.inl.h"
  #include "libANGLE/entry_points_utils.h"
  #include "libANGLE/gl_enum_utils.h"
  #include "libANGLE/validationEGL.h"
  #include "libANGLE/validationES.h"
  #include "libANGLE/validationES1.h"
  #include "libANGLE/validationES2.h"
  #include "libANGLE/validationES3.h"
  #include "libANGLE/validationES31.h"
  #include "libANGLE/validationES32.h"
  #include "libANGLE/validationESEXT.h"
  #include "libANGLE/validationGL4_autogen.h"
  #include "libGLESv2/global_state.h"
  
  namespace gl
  {
  void GL_APIENTRY BeginQueryIndexed(GLenum target, GLuint index, GLuint id)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glBeginQueryIndexed",
            "context = %d, GLenum target = %s, GLuint index = %u, GLuint id = %u", CID(context),
            GLenumToString(GLenumGroup::QueryTarget, target), index, id);
  
      if (context)
      {
          QueryID idPacked                              = FromGL<QueryID>(id);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateBeginQueryIndexed(context, target, index, idPacked));
          if (isCallValid)
          {
              context->beginQueryIndexed(target, index, idPacked);
          }
          ANGLE_CAPTURE(BeginQueryIndexed, isCallValid, context, target, index, idPacked);
      }
  }
  
  void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glBindTransformFeedback", "context = %d, GLenum target = %s, GLuint id = %u",
            CID(context), GLenumToString(GLenumGroup::BindTransformFeedbackTarget, target), id);
  
      if (context)
      {
          TransformFeedbackID idPacked                  = FromGL<TransformFeedbackID>(id);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateBindTransformFeedback(context, target, idPacked));
          if (isCallValid)
          {
              context->bindTransformFeedback(target, idPacked);
          }
          ANGLE_CAPTURE(BindTransformFeedback, isCallValid, context, target, idPacked);
      }
  }
  
  void GL_APIENTRY BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glBlendEquationSeparatei",
            "context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
            buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
            GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateBlendEquationSeparatei(context, buf, modeRGB, modeAlpha));
          if (isCallValid)
          {
              context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
          }
          ANGLE_CAPTURE(BlendEquationSeparatei, isCallValid, context, buf, modeRGB, modeAlpha);
      }
  }
  
  void GL_APIENTRY BlendEquationi(GLuint buf, GLenum mode)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glBlendEquationi", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context), buf,
            GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateBlendEquationi(context, buf, mode));
          if (isCallValid)
          {
              context->blendEquationi(buf, mode);
          }
          ANGLE_CAPTURE(BlendEquationi, isCallValid, context, buf, mode);
      }
  }
  
  void GL_APIENTRY
  BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glBlendFuncSeparatei",
            "context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
            "= %s, GLenum dstAlpha = %s",
            CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
            GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
            GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
            GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() ||
               ValidateBlendFuncSeparatei(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
          if (isCallValid)
          {
              context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
          }
          ANGLE_CAPTURE(BlendFuncSeparatei, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
                        dstAlpha);
      }
  }
  
  void GL_APIENTRY BlendFunci(GLuint buf, GLenum src, GLenum dst)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glBlendFunci", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
            CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
            GLenumToString(GLenumGroup::BlendingFactor, dst));
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateBlendFunci(context, buf, src, dst));
          if (isCallValid)
          {
              context->blendFunci(buf, src, dst);
          }
          ANGLE_CAPTURE(BlendFunci, isCallValid, context, buf, src, dst);
      }
  }
  
  void GL_APIENTRY DeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glDeleteTransformFeedbacks",
            "context = %d, GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
            (uintptr_t)ids);
  
      if (context)
      {
          const TransformFeedbackID *idsPacked          = FromGL<const TransformFeedbackID *>(ids);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateDeleteTransformFeedbacks(context, n, idsPacked));
          if (isCallValid)
          {
              context->deleteTransformFeedbacks(n, idsPacked);
          }
          ANGLE_CAPTURE(DeleteTransformFeedbacks, isCallValid, context, n, idsPacked);
      }
  }
  
  void GL_APIENTRY DrawArraysIndirect(GLenum mode, const void *indirect)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glDrawArraysIndirect",
            "context = %d, GLenum mode = %s, const void *indirect = 0x%016" PRIxPTR "", CID(context),
            GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect);
  
      if (context)
      {
          PrimitiveMode modePacked                      = FromGL<PrimitiveMode>(mode);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateDrawArraysIndirect(context, modePacked, indirect));
          if (isCallValid)
          {
              context->drawArraysIndirect(modePacked, indirect);
          }
          ANGLE_CAPTURE(DrawArraysIndirect, isCallValid, context, modePacked, indirect);
      }
  }
  
  void GL_APIENTRY DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glDrawElementsIndirect",
            "context = %d, GLenum mode = %s, GLenum type = %s, const void *indirect = 0x%016" PRIxPTR
            "",
            CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode),
            GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect);
  
      if (context)
      {
          PrimitiveMode modePacked                      = FromGL<PrimitiveMode>(mode);
          DrawElementsType typePacked                   = FromGL<DrawElementsType>(type);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() ||
               ValidateDrawElementsIndirect(context, modePacked, typePacked, indirect));
          if (isCallValid)
          {
              context->drawElementsIndirect(modePacked, typePacked, indirect);
          }
          ANGLE_CAPTURE(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, indirect);
      }
  }
  
  void GL_APIENTRY DrawTransformFeedback(GLenum mode, GLuint id)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glDrawTransformFeedback", "context = %d, GLenum mode = %s, GLuint id = %u", CID(context),
            GLenumToString(GLenumGroup::PrimitiveType, mode), id);
  
      if (context)
      {
          TransformFeedbackID idPacked                  = FromGL<TransformFeedbackID>(id);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateDrawTransformFeedback(context, mode, idPacked));
          if (isCallValid)
          {
              context->drawTransformFeedback(mode, idPacked);
          }
          ANGLE_CAPTURE(DrawTransformFeedback, isCallValid, context, mode, idPacked);
      }
  }
  
  void GL_APIENTRY DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glDrawTransformFeedbackStream",
            "context = %d, GLenum mode = %s, GLuint id = %u, GLuint stream = %u", CID(context),
            GLenumToString(GLenumGroup::PrimitiveType, mode), id, stream);
  
      if (context)
      {
          TransformFeedbackID idPacked                  = FromGL<TransformFeedbackID>(id);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateDrawTransformFeedbackStream(context, mode, idPacked, stream));
          if (isCallValid)
          {
              context->drawTransformFeedbackStream(mode, idPacked, stream);
          }
          ANGLE_CAPTURE(DrawTransformFeedbackStream, isCallValid, context, mode, idPacked, stream);
      }
  }
  
  void GL_APIENTRY EndQueryIndexed(GLenum target, GLuint index)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glEndQueryIndexed", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
            GLenumToString(GLenumGroup::QueryTarget, target), index);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateEndQueryIndexed(context, target, index));
          if (isCallValid)
          {
              context->endQueryIndexed(target, index);
          }
          ANGLE_CAPTURE(EndQueryIndexed, isCallValid, context, target, index);
      }
  }
  
  void GL_APIENTRY GenTransformFeedbacks(GLsizei n, GLuint *ids)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGenTransformFeedbacks",
            "context = %d, GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
            (uintptr_t)ids);
  
      if (context)
      {
          TransformFeedbackID *idsPacked                = FromGL<TransformFeedbackID *>(ids);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateGenTransformFeedbacks(context, n, idsPacked));
          if (isCallValid)
          {
              context->genTransformFeedbacks(n, idsPacked);
          }
          ANGLE_CAPTURE(GenTransformFeedbacks, isCallValid, context, n, idsPacked);
      }
  }
  
  void GL_APIENTRY GetActiveSubroutineName(GLuint program,
                                           GLenum shadertype,
                                           GLuint index,
                                           GLsizei bufsize,
                                           GLsizei *length,
                                           GLchar *name)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGetActiveSubroutineName",
            "context = %d, GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLsizei "
            "bufsize = %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
            CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index,
            bufsize, (uintptr_t)length, (uintptr_t)name);
  
      if (context)
      {
          ShaderProgramID programPacked                 = FromGL<ShaderProgramID>(program);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateGetActiveSubroutineName(context, programPacked, shadertype,
                                                              index, bufsize, length, name));
          if (isCallValid)
          {
              context->getActiveSubroutineName(programPacked, shadertype, index, bufsize, length,
                                               name);
          }
          ANGLE_CAPTURE(GetActiveSubroutineName, isCallValid, context, programPacked, shadertype,
                        index, bufsize, length, name);
      }
  }
  
  void GL_APIENTRY GetActiveSubroutineUniformName(GLuint program,
                                                  GLenum shadertype,
                                                  GLuint index,
                                                  GLsizei bufsize,
                                                  GLsizei *length,
                                                  GLchar *name)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGetActiveSubroutineUniformName",
            "context = %d, GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLsizei "
            "bufsize = %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
            CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index,
            bufsize, (uintptr_t)length, (uintptr_t)name);
  
      if (context)
      {
          ShaderProgramID programPacked                 = FromGL<ShaderProgramID>(program);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateGetActiveSubroutineUniformName(
                                  context, programPacked, shadertype, index, bufsize, length, name));
          if (isCallValid)
          {
              context->getActiveSubroutineUniformName(programPacked, shadertype, index, bufsize,
                                                      length, name);
          }
          ANGLE_CAPTURE(GetActiveSubroutineUniformName, isCallValid, context, programPacked,
                        shadertype, index, bufsize, length, name);
      }
  }
  
  void GL_APIENTRY GetActiveSubroutineUniformiv(GLuint program,
                                                GLenum shadertype,
                                                GLuint index,
                                                GLenum pname,
                                                GLint *values)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGetActiveSubroutineUniformiv",
            "context = %d, GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLenum "
            "pname = %s, GLint *values = 0x%016" PRIxPTR "",
            CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index,
            GLenumToString(GLenumGroup::SubroutineParameterName, pname), (uintptr_t)values);
  
      if (context)
      {
          ShaderProgramID programPacked                 = FromGL<ShaderProgramID>(program);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateGetActiveSubroutineUniformiv(context, programPacked, shadertype,
                                                                   index, pname, values));
          if (isCallValid)
          {
              context->getActiveSubroutineUniformiv(programPacked, shadertype, index, pname, values);
          }
          ANGLE_CAPTURE(GetActiveSubroutineUniformiv, isCallValid, context, programPacked, shadertype,
                        index, pname, values);
      }
  }
  
  void GL_APIENTRY GetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGetProgramStageiv",
            "context = %d, GLuint program = %u, GLenum shadertype = %s, GLenum pname = %s, GLint "
            "*values = 0x%016" PRIxPTR "",
            CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype),
            GLenumToString(GLenumGroup::ProgramStagePName, pname), (uintptr_t)values);
  
      if (context)
      {
          ShaderProgramID programPacked                 = FromGL<ShaderProgramID>(program);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() ||
               ValidateGetProgramStageiv(context, programPacked, shadertype, pname, values));
          if (isCallValid)
          {
              context->getProgramStageiv(programPacked, shadertype, pname, values);
          }
          ANGLE_CAPTURE(GetProgramStageiv, isCallValid, context, programPacked, shadertype, pname,
                        values);
      }
  }
  
  void GL_APIENTRY GetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGetQueryIndexediv",
            "context = %d, GLenum target = %s, GLuint index = %u, GLenum pname = %s, GLint *params = "
            "0x%016" PRIxPTR "",
            CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index,
            GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateGetQueryIndexediv(context, target, index, pname, params));
          if (isCallValid)
          {
              context->getQueryIndexediv(target, index, pname, params);
          }
          ANGLE_CAPTURE(GetQueryIndexediv, isCallValid, context, target, index, pname, params);
      }
  }
  
  GLuint GL_APIENTRY GetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGetSubroutineIndex",
            "context = %d, GLuint program = %u, GLenum shadertype = %s, const GLchar *name = "
            "0x%016" PRIxPTR "",
            CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype),
            (uintptr_t)name);
  
      GLuint returnValue;
      if (context)
      {
          ShaderProgramID programPacked                 = FromGL<ShaderProgramID>(program);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateGetSubroutineIndex(context, programPacked, shadertype, name));
          if (isCallValid)
          {
              returnValue = context->getSubroutineIndex(programPacked, shadertype, name);
          }
          else
          {
              returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineIndex, GLuint>();
          }
          ANGLE_CAPTURE(GetSubroutineIndex, isCallValid, context, programPacked, shadertype, name,
                        returnValue);
      }
      else
      {
          returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineIndex, GLuint>();
      }
      return returnValue;
  }
  
  GLint GL_APIENTRY GetSubroutineUniformLocation(GLuint program,
                                                 GLenum shadertype,
                                                 const GLchar *name)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glGetSubroutineUniformLocation",
            "context = %d, GLuint program = %u, GLenum shadertype = %s, const GLchar *name = "
            "0x%016" PRIxPTR "",
            CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype),
            (uintptr_t)name);
  
      GLint returnValue;
      if (context)
      {
          ShaderProgramID programPacked                 = FromGL<ShaderProgramID>(program);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() ||
               ValidateGetSubroutineUniformLocation(context, programPacked, shadertype, name));
          if (isCallValid)
          {
              returnValue = context->getSubroutineUniformLocation(programPacked, shadertype, name);
          }
          else
          {
              returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineUniformLocation, GLint>();
          }
          ANGLE_CAPTURE(GetSubroutineUniformLocation, isCallValid, context, programPacked, shadertype,
                        name, returnValue);
      }
      else
      {
          returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineUniformLocation, GLint>();
      }
      return returnValue;
  }
  
  void GL_APIENTRY GetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
  {
      Context *context = GetValidGlobalContext();
      EVENT(
          "glGetUniformSubroutineuiv",
          "context = %d, GLenum shadertype = %s, GLint location = %d, GLuint *params = 0x%016" PRIxPTR
          "",
          CID(context), GLenumToString(GLenumGroup::ShaderType, shadertype), location,
          (uintptr_t)params);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateGetUniformSubroutineuiv(context, shadertype, location, params));
          if (isCallValid)
          {
              context->getUniformSubroutineuiv(shadertype, location, params);
          }
          ANGLE_CAPTURE(GetUniformSubroutineuiv, isCallValid, context, shadertype, location, params);
      }
  }
  
  void GL_APIENTRY GetUniformdv(GLuint program, GLint location, GLdouble *params)
  {
      Context *context = GetValidGlobalContext();
      EVENT(
          "glGetUniformdv",
          "context = %d, GLuint program = %u, GLint location = %d, GLdouble *params = 0x%016" PRIxPTR
          "",
          CID(context), program, location, (uintptr_t)params);
  
      if (context)
      {
          ShaderProgramID programPacked                 = FromGL<ShaderProgramID>(program);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateGetUniformdv(context, programPacked, location, params));
          if (isCallValid)
          {
              context->getUniformdv(programPacked, location, params);
          }
          ANGLE_CAPTURE(GetUniformdv, isCallValid, context, programPacked, location, params);
      }
  }
  
  GLboolean GL_APIENTRY IsTransformFeedback(GLuint id)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glIsTransformFeedback", "context = %d, GLuint id = %u", CID(context), id);
  
      GLboolean returnValue;
      if (context)
      {
          TransformFeedbackID idPacked                  = FromGL<TransformFeedbackID>(id);
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateIsTransformFeedback(context, idPacked));
          if (isCallValid)
          {
              returnValue = context->isTransformFeedback(idPacked);
          }
          else
          {
              returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
          }
          ANGLE_CAPTURE(IsTransformFeedback, isCallValid, context, idPacked, returnValue);
      }
      else
      {
          returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
      }
      return returnValue;
  }
  
  void GL_APIENTRY MinSampleShading(GLfloat value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glMinSampleShading", "context = %d, GLfloat value = %f", CID(context), value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid = (context->skipValidation() || ValidateMinSampleShading(context, value));
          if (isCallValid)
          {
              context->minSampleShading(value);
          }
          ANGLE_CAPTURE(MinSampleShading, isCallValid, context, value);
      }
  }
  
  void GL_APIENTRY PatchParameterfv(GLenum pname, const GLfloat *values)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glPatchParameterfv",
            "context = %d, GLenum pname = %s, const GLfloat *values = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(GLenumGroup::PatchParameterName, pname), (uintptr_t)values);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidatePatchParameterfv(context, pname, values));
          if (isCallValid)
          {
              context->patchParameterfv(pname, values);
          }
          ANGLE_CAPTURE(PatchParameterfv, isCallValid, context, pname, values);
      }
  }
  
  void GL_APIENTRY PatchParameteri(GLenum pname, GLint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glPatchParameteri", "context = %d, GLenum pname = %s, GLint value = %d", CID(context),
            GLenumToString(GLenumGroup::PatchParameterName, pname), value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidatePatchParameteri(context, pname, value));
          if (isCallValid)
          {
              context->patchParameteri(pname, value);
          }
          ANGLE_CAPTURE(PatchParameteri, isCallValid, context, pname, value);
      }
  }
  
  void GL_APIENTRY PauseTransformFeedback()
  {
      Context *context = GetValidGlobalContext();
      EVENT("glPauseTransformFeedback", "context = %d", CID(context));
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid = (context->skipValidation() || ValidatePauseTransformFeedback(context));
          if (isCallValid)
          {
              context->pauseTransformFeedback();
          }
          ANGLE_CAPTURE(PauseTransformFeedback, isCallValid, context);
      }
  }
  
  void GL_APIENTRY ResumeTransformFeedback()
  {
      Context *context = GetValidGlobalContext();
      EVENT("glResumeTransformFeedback", "context = %d", CID(context));
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid = (context->skipValidation() || ValidateResumeTransformFeedback(context));
          if (isCallValid)
          {
              context->resumeTransformFeedback();
          }
          ANGLE_CAPTURE(ResumeTransformFeedback, isCallValid, context);
      }
  }
  
  void GL_APIENTRY Uniform1d(GLint location, GLdouble x)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform1d", "context = %d, GLint location = %d, GLdouble x = %f", CID(context),
            location, x);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid = (context->skipValidation() || ValidateUniform1d(context, location, x));
          if (isCallValid)
          {
              context->uniform1d(location, x);
          }
          ANGLE_CAPTURE(Uniform1d, isCallValid, context, location, x);
      }
  }
  
  void GL_APIENTRY Uniform1dv(GLint location, GLsizei count, const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform1dv",
            "context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
            "0x%016" PRIxPTR "",
            CID(context), location, count, (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateUniform1dv(context, location, count, value));
          if (isCallValid)
          {
              context->uniform1dv(location, count, value);
          }
          ANGLE_CAPTURE(Uniform1dv, isCallValid, context, location, count, value);
      }
  }
  
  void GL_APIENTRY Uniform2d(GLint location, GLdouble x, GLdouble y)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform2d", "context = %d, GLint location = %d, GLdouble x = %f, GLdouble y = %f",
            CID(context), location, x, y);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateUniform2d(context, location, x, y));
          if (isCallValid)
          {
              context->uniform2d(location, x, y);
          }
          ANGLE_CAPTURE(Uniform2d, isCallValid, context, location, x, y);
      }
  }
  
  void GL_APIENTRY Uniform2dv(GLint location, GLsizei count, const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform2dv",
            "context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
            "0x%016" PRIxPTR "",
            CID(context), location, count, (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateUniform2dv(context, location, count, value));
          if (isCallValid)
          {
              context->uniform2dv(location, count, value);
          }
          ANGLE_CAPTURE(Uniform2dv, isCallValid, context, location, count, value);
      }
  }
  
  void GL_APIENTRY Uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform3d",
            "context = %d, GLint location = %d, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f",
            CID(context), location, x, y, z);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateUniform3d(context, location, x, y, z));
          if (isCallValid)
          {
              context->uniform3d(location, x, y, z);
          }
          ANGLE_CAPTURE(Uniform3d, isCallValid, context, location, x, y, z);
      }
  }
  
  void GL_APIENTRY Uniform3dv(GLint location, GLsizei count, const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform3dv",
            "context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
            "0x%016" PRIxPTR "",
            CID(context), location, count, (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateUniform3dv(context, location, count, value));
          if (isCallValid)
          {
              context->uniform3dv(location, count, value);
          }
          ANGLE_CAPTURE(Uniform3dv, isCallValid, context, location, count, value);
      }
  }
  
  void GL_APIENTRY Uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform4d",
            "context = %d, GLint location = %d, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, "
            "GLdouble w = %f",
            CID(context), location, x, y, z, w);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateUniform4d(context, location, x, y, z, w));
          if (isCallValid)
          {
              context->uniform4d(location, x, y, z, w);
          }
          ANGLE_CAPTURE(Uniform4d, isCallValid, context, location, x, y, z, w);
      }
  }
  
  void GL_APIENTRY Uniform4dv(GLint location, GLsizei count, const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniform4dv",
            "context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
            "0x%016" PRIxPTR "",
            CID(context), location, count, (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateUniform4dv(context, location, count, value));
          if (isCallValid)
          {
              context->uniform4dv(location, count, value);
          }
          ANGLE_CAPTURE(Uniform4dv, isCallValid, context, location, count, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix2dv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix2dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix2dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix2dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix2dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix2x3dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix2x3dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix2x3dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix2x3dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix2x3dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix2x4dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix2x4dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix2x4dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix2x4dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix2x4dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix3dv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix3dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix3dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix3dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix3dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix3x2dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix3x2dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix3x2dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix3x2dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix3x2dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix3x4dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix3x4dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix3x4dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix3x4dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix3x4dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix4dv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix4dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix4dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix4dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix4dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix4x2dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix4x2dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix4x2dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix4x2dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix4x2dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformMatrix4x3dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformMatrix4x3dv",
            "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
            "GLdouble *value = 0x%016" PRIxPTR "",
            CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformMatrix4x3dv(context, location, count, transpose, value));
          if (isCallValid)
          {
              context->uniformMatrix4x3dv(location, count, transpose, value);
          }
          ANGLE_CAPTURE(UniformMatrix4x3dv, isCallValid, context, location, count, transpose, value);
      }
  }
  
  void GL_APIENTRY UniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
  {
      Context *context = GetValidGlobalContext();
      EVENT("glUniformSubroutinesuiv",
            "context = %d, GLenum shadertype = %s, GLsizei count = %d, const GLuint *indices = "
            "0x%016" PRIxPTR "",
            CID(context), GLenumToString(GLenumGroup::ShaderType, shadertype), count,
            (uintptr_t)indices);
  
      if (context)
      {
          std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                              = (context->skipValidation() ||
                              ValidateUniformSubroutinesuiv(context, shadertype, count, indices));
          if (isCallValid)
          {
              context->uniformSubroutinesuiv(shadertype, count, indices);
          }
          ANGLE_CAPTURE(UniformSubroutinesuiv, isCallValid, context, shadertype, count, indices);
      }
  }
  }  // namespace gl