// 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_3_3_autogen.cpp:
//   Defines the GL 3.3 entry points.

#include "libGL/entry_points_gl_3_3_autogen.h"

#include "libANGLE/Context.h"
#include "libANGLE/Context.inl.h"
#include "libANGLE/entry_points_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/validationESEXT.h"
#include "libANGLE/validationGL33_autogen.h"
#include "libGLESv2/global_state.h"

namespace gl
{
void GL_APIENTRY BindFragDataLocationIndexed(GLuint program,
                                             GLuint colorNumber,
                                             GLuint index,
                                             const GLchar *name)
{
    EVENT(
        "(GLuint program = %u, GLuint colorNumber = %u, GLuint index = %u, const GLchar *name = "
        "0x%016" PRIxPTR ")",
        program, colorNumber, index, (uintptr_t)name);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(BindFragDataLocationIndexed, context, program, colorNumber, index, name);
        if (context->skipValidation() ||
            ValidateBindFragDataLocationIndexed(context, program, colorNumber, index, name))
        {
            context->bindFragDataLocationIndexed(program, colorNumber, index, name);
        }
    }
}

void GL_APIENTRY BindSampler(GLuint unit, GLuint sampler)
{
    EVENT("(GLuint unit = %u, GLuint sampler = %u)", unit, sampler);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(BindSampler, context, unit, sampler);
        if (context->skipValidation() || ValidateBindSampler(context, unit, sampler))
        {
            context->bindSampler(unit, sampler);
        }
    }
}

void GL_APIENTRY ColorP3ui(GLenum type, GLuint color)
{
    EVENT("(GLenum type = 0x%X, GLuint color = %u)", type, color);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(ColorP3ui, context, type, color);
        if (context->skipValidation() || ValidateColorP3ui(context, type, color))
        {
            context->colorP3ui(type, color);
        }
    }
}

void GL_APIENTRY ColorP3uiv(GLenum type, const GLuint *color)
{
    EVENT("(GLenum type = 0x%X, const GLuint *color = 0x%016" PRIxPTR ")", type, (uintptr_t)color);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(ColorP3uiv, context, type, color);
        if (context->skipValidation() || ValidateColorP3uiv(context, type, color))
        {
            context->colorP3uiv(type, color);
        }
    }
}

void GL_APIENTRY ColorP4ui(GLenum type, GLuint color)
{
    EVENT("(GLenum type = 0x%X, GLuint color = %u)", type, color);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(ColorP4ui, context, type, color);
        if (context->skipValidation() || ValidateColorP4ui(context, type, color))
        {
            context->colorP4ui(type, color);
        }
    }
}

void GL_APIENTRY ColorP4uiv(GLenum type, const GLuint *color)
{
    EVENT("(GLenum type = 0x%X, const GLuint *color = 0x%016" PRIxPTR ")", type, (uintptr_t)color);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(ColorP4uiv, context, type, color);
        if (context->skipValidation() || ValidateColorP4uiv(context, type, color))
        {
            context->colorP4uiv(type, color);
        }
    }
}

void GL_APIENTRY DeleteSamplers(GLsizei count, const GLuint *samplers)
{
    EVENT("(GLsizei count = %d, const GLuint *samplers = 0x%016" PRIxPTR ")", count,
          (uintptr_t)samplers);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(DeleteSamplers, context, count, samplers);
        if (context->skipValidation() || ValidateDeleteSamplers(context, count, samplers))
        {
            context->deleteSamplers(count, samplers);
        }
    }
}

void GL_APIENTRY GenSamplers(GLsizei count, GLuint *samplers)
{
    EVENT("(GLsizei count = %d, GLuint *samplers = 0x%016" PRIxPTR ")", count, (uintptr_t)samplers);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GenSamplers, context, count, samplers);
        if (context->skipValidation() || ValidateGenSamplers(context, count, samplers))
        {
            context->genSamplers(count, samplers);
        }
    }
}

GLint GL_APIENTRY GetFragDataIndex(GLuint program, const GLchar *name)
{
    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
          (uintptr_t)name);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GetFragDataIndex, context, program, name);
        if (context->skipValidation() || ValidateGetFragDataIndex(context, program, name))
        {
            return context->getFragDataIndex(program, name);
        }
    }

    return GetDefaultReturnValue<EntryPoint::GetFragDataIndex, GLint>();
}

void GL_APIENTRY GetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
{
    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLint64 *params = 0x%016" PRIxPTR ")", id, pname,
          (uintptr_t)params);

    Context *context = GetGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GetQueryObjecti64v, context, id, pname, params);
        if (context->skipValidation() || ValidateGetQueryObjecti64v(context, id, pname, params))
        {
            context->getQueryObjecti64v(id, pname, params);
        }
    }
}

void GL_APIENTRY GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
{
    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLuint64 *params = 0x%016" PRIxPTR ")", id, pname,
          (uintptr_t)params);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GetQueryObjectui64v, context, id, pname, params);
        if (context->skipValidation() || ValidateGetQueryObjectui64v(context, id, pname, params))
        {
            context->getQueryObjectui64v(id, pname, params);
        }
    }
}

void GL_APIENTRY GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", sampler,
          pname, (uintptr_t)params);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GetSamplerParameterIiv, context, sampler, pname, params);
        if (context->skipValidation() ||
            ValidateGetSamplerParameterIiv(context, sampler, pname, params))
        {
            context->getSamplerParameterIiv(sampler, pname, params);
        }
    }
}

void GL_APIENTRY GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", sampler,
          pname, (uintptr_t)params);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GetSamplerParameterIuiv, context, sampler, pname, params);
        if (context->skipValidation() ||
            ValidateGetSamplerParameterIuiv(context, sampler, pname, params))
        {
            context->getSamplerParameterIuiv(sampler, pname, params);
        }
    }
}

void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")",
          sampler, pname, (uintptr_t)params);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GetSamplerParameterfv, context, sampler, pname, params);
        if (context->skipValidation() ||
            ValidateGetSamplerParameterfv(context, sampler, pname, params))
        {
            context->getSamplerParameterfv(sampler, pname, params);
        }
    }
}

void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", sampler,
          pname, (uintptr_t)params);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(GetSamplerParameteriv, context, sampler, pname, params);
        if (context->skipValidation() ||
            ValidateGetSamplerParameteriv(context, sampler, pname, params))
        {
            context->getSamplerParameteriv(sampler, pname, params);
        }
    }
}

GLboolean GL_APIENTRY IsSampler(GLuint sampler)
{
    EVENT("(GLuint sampler = %u)", sampler);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(IsSampler, context, sampler);
        if (context->skipValidation() || ValidateIsSampler(context, sampler))
        {
            return context->isSampler(sampler);
        }
    }

    return GetDefaultReturnValue<EntryPoint::IsSampler, GLboolean>();
}

void GL_APIENTRY MultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, GLuint coords = %u)", texture, type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP1ui, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP1ui(context, texture, type, coords))
        {
            context->multiTexCoordP1ui(texture, type, coords);
        }
    }
}

void GL_APIENTRY MultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")",
          texture, type, (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP1uiv, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP1uiv(context, texture, type, coords))
        {
            context->multiTexCoordP1uiv(texture, type, coords);
        }
    }
}

void GL_APIENTRY MultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, GLuint coords = %u)", texture, type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP2ui, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP2ui(context, texture, type, coords))
        {
            context->multiTexCoordP2ui(texture, type, coords);
        }
    }
}

void GL_APIENTRY MultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")",
          texture, type, (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP2uiv, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP2uiv(context, texture, type, coords))
        {
            context->multiTexCoordP2uiv(texture, type, coords);
        }
    }
}

void GL_APIENTRY MultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, GLuint coords = %u)", texture, type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP3ui, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP3ui(context, texture, type, coords))
        {
            context->multiTexCoordP3ui(texture, type, coords);
        }
    }
}

void GL_APIENTRY MultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")",
          texture, type, (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP3uiv, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP3uiv(context, texture, type, coords))
        {
            context->multiTexCoordP3uiv(texture, type, coords);
        }
    }
}

void GL_APIENTRY MultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, GLuint coords = %u)", texture, type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP4ui, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP4ui(context, texture, type, coords))
        {
            context->multiTexCoordP4ui(texture, type, coords);
        }
    }
}

void GL_APIENTRY MultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    EVENT("(GLenum texture = 0x%X, GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")",
          texture, type, (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(MultiTexCoordP4uiv, context, texture, type, coords);
        if (context->skipValidation() || ValidateMultiTexCoordP4uiv(context, texture, type, coords))
        {
            context->multiTexCoordP4uiv(texture, type, coords);
        }
    }
}

void GL_APIENTRY NormalP3ui(GLenum type, GLuint coords)
{
    EVENT("(GLenum type = 0x%X, GLuint coords = %u)", type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(NormalP3ui, context, type, coords);
        if (context->skipValidation() || ValidateNormalP3ui(context, type, coords))
        {
            context->normalP3ui(type, coords);
        }
    }
}

void GL_APIENTRY NormalP3uiv(GLenum type, const GLuint *coords)
{
    EVENT("(GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")", type,
          (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(NormalP3uiv, context, type, coords);
        if (context->skipValidation() || ValidateNormalP3uiv(context, type, coords))
        {
            context->normalP3uiv(type, coords);
        }
    }
}

void GL_APIENTRY QueryCounter(GLuint id, GLenum target)
{
    EVENT("(GLuint id = %u, GLenum target = 0x%X)", id, target);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        QueryType targetPacked = FromGLenum<QueryType>(target);
        ANGLE_CAPTURE(QueryCounter, context, id, targetPacked);
        if (context->skipValidation() || ValidateQueryCounter(context, id, targetPacked))
        {
            context->queryCounter(id, targetPacked);
        }
    }
}

void GL_APIENTRY SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLint *param = 0x%016" PRIxPTR ")",
          sampler, pname, (uintptr_t)param);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SamplerParameterIiv, context, sampler, pname, param);
        if (context->skipValidation() ||
            ValidateSamplerParameterIiv(context, sampler, pname, param))
        {
            context->samplerParameterIiv(sampler, pname, param);
        }
    }
}

void GL_APIENTRY SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLuint *param = 0x%016" PRIxPTR ")",
          sampler, pname, (uintptr_t)param);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SamplerParameterIuiv, context, sampler, pname, param);
        if (context->skipValidation() ||
            ValidateSamplerParameterIuiv(context, sampler, pname, param))
        {
            context->samplerParameterIuiv(sampler, pname, param);
        }
    }
}

void GL_APIENTRY SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLfloat param = %f)", sampler, pname, param);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SamplerParameterf, context, sampler, pname, param);
        if (context->skipValidation() || ValidateSamplerParameterf(context, sampler, pname, param))
        {
            context->samplerParameterf(sampler, pname, param);
        }
    }
}

void GL_APIENTRY SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLfloat *param = 0x%016" PRIxPTR ")",
          sampler, pname, (uintptr_t)param);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SamplerParameterfv, context, sampler, pname, param);
        if (context->skipValidation() || ValidateSamplerParameterfv(context, sampler, pname, param))
        {
            context->samplerParameterfv(sampler, pname, param);
        }
    }
}

void GL_APIENTRY SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint param = %d)", sampler, pname, param);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SamplerParameteri, context, sampler, pname, param);
        if (context->skipValidation() || ValidateSamplerParameteri(context, sampler, pname, param))
        {
            context->samplerParameteri(sampler, pname, param);
        }
    }
}

void GL_APIENTRY SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
{
    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLint *param = 0x%016" PRIxPTR ")",
          sampler, pname, (uintptr_t)param);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SamplerParameteriv, context, sampler, pname, param);
        if (context->skipValidation() || ValidateSamplerParameteriv(context, sampler, pname, param))
        {
            context->samplerParameteriv(sampler, pname, param);
        }
    }
}

void GL_APIENTRY SecondaryColorP3ui(GLenum type, GLuint color)
{
    EVENT("(GLenum type = 0x%X, GLuint color = %u)", type, color);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SecondaryColorP3ui, context, type, color);
        if (context->skipValidation() || ValidateSecondaryColorP3ui(context, type, color))
        {
            context->secondaryColorP3ui(type, color);
        }
    }
}

void GL_APIENTRY SecondaryColorP3uiv(GLenum type, const GLuint *color)
{
    EVENT("(GLenum type = 0x%X, const GLuint *color = 0x%016" PRIxPTR ")", type, (uintptr_t)color);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(SecondaryColorP3uiv, context, type, color);
        if (context->skipValidation() || ValidateSecondaryColorP3uiv(context, type, color))
        {
            context->secondaryColorP3uiv(type, color);
        }
    }
}

void GL_APIENTRY TexCoordP1ui(GLenum type, GLuint coords)
{
    EVENT("(GLenum type = 0x%X, GLuint coords = %u)", type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP1ui, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP1ui(context, type, coords))
        {
            context->texCoordP1ui(type, coords);
        }
    }
}

void GL_APIENTRY TexCoordP1uiv(GLenum type, const GLuint *coords)
{
    EVENT("(GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")", type,
          (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP1uiv, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP1uiv(context, type, coords))
        {
            context->texCoordP1uiv(type, coords);
        }
    }
}

void GL_APIENTRY TexCoordP2ui(GLenum type, GLuint coords)
{
    EVENT("(GLenum type = 0x%X, GLuint coords = %u)", type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP2ui, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP2ui(context, type, coords))
        {
            context->texCoordP2ui(type, coords);
        }
    }
}

void GL_APIENTRY TexCoordP2uiv(GLenum type, const GLuint *coords)
{
    EVENT("(GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")", type,
          (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP2uiv, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP2uiv(context, type, coords))
        {
            context->texCoordP2uiv(type, coords);
        }
    }
}

void GL_APIENTRY TexCoordP3ui(GLenum type, GLuint coords)
{
    EVENT("(GLenum type = 0x%X, GLuint coords = %u)", type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP3ui, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP3ui(context, type, coords))
        {
            context->texCoordP3ui(type, coords);
        }
    }
}

void GL_APIENTRY TexCoordP3uiv(GLenum type, const GLuint *coords)
{
    EVENT("(GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")", type,
          (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP3uiv, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP3uiv(context, type, coords))
        {
            context->texCoordP3uiv(type, coords);
        }
    }
}

void GL_APIENTRY TexCoordP4ui(GLenum type, GLuint coords)
{
    EVENT("(GLenum type = 0x%X, GLuint coords = %u)", type, coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP4ui, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP4ui(context, type, coords))
        {
            context->texCoordP4ui(type, coords);
        }
    }
}

void GL_APIENTRY TexCoordP4uiv(GLenum type, const GLuint *coords)
{
    EVENT("(GLenum type = 0x%X, const GLuint *coords = 0x%016" PRIxPTR ")", type,
          (uintptr_t)coords);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(TexCoordP4uiv, context, type, coords);
        if (context->skipValidation() || ValidateTexCoordP4uiv(context, type, coords))
        {
            context->texCoordP4uiv(type, coords);
        }
    }
}

void GL_APIENTRY VertexAttribDivisor(GLuint index, GLuint divisor)
{
    EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribDivisor, context, index, divisor);
        if (context->skipValidation() || ValidateVertexAttribDivisor(context, index, divisor))
        {
            context->vertexAttribDivisor(index, divisor);
        }
    }
}

void GL_APIENTRY VertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    EVENT("(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, GLuint value = %u)",
          index, type, normalized, value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP1ui, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP1ui(context, index, type, normalized, value))
        {
            context->vertexAttribP1ui(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexAttribP1uiv(GLuint index,
                                   GLenum type,
                                   GLboolean normalized,
                                   const GLuint *value)
{
    EVENT(
        "(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, const GLuint *value = "
        "0x%016" PRIxPTR ")",
        index, type, normalized, (uintptr_t)value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP1uiv, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP1uiv(context, index, type, normalized, value))
        {
            context->vertexAttribP1uiv(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    EVENT("(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, GLuint value = %u)",
          index, type, normalized, value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP2ui, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP2ui(context, index, type, normalized, value))
        {
            context->vertexAttribP2ui(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexAttribP2uiv(GLuint index,
                                   GLenum type,
                                   GLboolean normalized,
                                   const GLuint *value)
{
    EVENT(
        "(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, const GLuint *value = "
        "0x%016" PRIxPTR ")",
        index, type, normalized, (uintptr_t)value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP2uiv, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP2uiv(context, index, type, normalized, value))
        {
            context->vertexAttribP2uiv(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    EVENT("(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, GLuint value = %u)",
          index, type, normalized, value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP3ui, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP3ui(context, index, type, normalized, value))
        {
            context->vertexAttribP3ui(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexAttribP3uiv(GLuint index,
                                   GLenum type,
                                   GLboolean normalized,
                                   const GLuint *value)
{
    EVENT(
        "(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, const GLuint *value = "
        "0x%016" PRIxPTR ")",
        index, type, normalized, (uintptr_t)value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP3uiv, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP3uiv(context, index, type, normalized, value))
        {
            context->vertexAttribP3uiv(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    EVENT("(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, GLuint value = %u)",
          index, type, normalized, value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP4ui, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP4ui(context, index, type, normalized, value))
        {
            context->vertexAttribP4ui(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexAttribP4uiv(GLuint index,
                                   GLenum type,
                                   GLboolean normalized,
                                   const GLuint *value)
{
    EVENT(
        "(GLuint index = %u, GLenum type = 0x%X, GLboolean normalized = %u, const GLuint *value = "
        "0x%016" PRIxPTR ")",
        index, type, normalized, (uintptr_t)value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexAttribP4uiv, context, index, type, normalized, value);
        if (context->skipValidation() ||
            ValidateVertexAttribP4uiv(context, index, type, normalized, value))
        {
            context->vertexAttribP4uiv(index, type, normalized, value);
        }
    }
}

void GL_APIENTRY VertexP2ui(GLenum type, GLuint value)
{
    EVENT("(GLenum type = 0x%X, GLuint value = %u)", type, value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexP2ui, context, type, value);
        if (context->skipValidation() || ValidateVertexP2ui(context, type, value))
        {
            context->vertexP2ui(type, value);
        }
    }
}

void GL_APIENTRY VertexP2uiv(GLenum type, const GLuint *value)
{
    EVENT("(GLenum type = 0x%X, const GLuint *value = 0x%016" PRIxPTR ")", type, (uintptr_t)value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexP2uiv, context, type, value);
        if (context->skipValidation() || ValidateVertexP2uiv(context, type, value))
        {
            context->vertexP2uiv(type, value);
        }
    }
}

void GL_APIENTRY VertexP3ui(GLenum type, GLuint value)
{
    EVENT("(GLenum type = 0x%X, GLuint value = %u)", type, value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexP3ui, context, type, value);
        if (context->skipValidation() || ValidateVertexP3ui(context, type, value))
        {
            context->vertexP3ui(type, value);
        }
    }
}

void GL_APIENTRY VertexP3uiv(GLenum type, const GLuint *value)
{
    EVENT("(GLenum type = 0x%X, const GLuint *value = 0x%016" PRIxPTR ")", type, (uintptr_t)value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexP3uiv, context, type, value);
        if (context->skipValidation() || ValidateVertexP3uiv(context, type, value))
        {
            context->vertexP3uiv(type, value);
        }
    }
}

void GL_APIENTRY VertexP4ui(GLenum type, GLuint value)
{
    EVENT("(GLenum type = 0x%X, GLuint value = %u)", type, value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexP4ui, context, type, value);
        if (context->skipValidation() || ValidateVertexP4ui(context, type, value))
        {
            context->vertexP4ui(type, value);
        }
    }
}

void GL_APIENTRY VertexP4uiv(GLenum type, const GLuint *value)
{
    EVENT("(GLenum type = 0x%X, const GLuint *value = 0x%016" PRIxPTR ")", type, (uintptr_t)value);

    Context *context = GetValidGlobalContext();
    if (context)
    {
        ANGLE_CAPTURE(VertexP4uiv, context, type, value);
        if (context->skipValidation() || ValidateVertexP4uiv(context, type, value))
        {
            context->vertexP4uiv(type, value);
        }
    }
}
}  // namespace gl
