chromium/gpu/command_buffer/client/gles2_cmd_helper_autogen.h

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file is auto-generated from
// gpu/command_buffer/build_gles2_cmd_buffer.py
// It's formatted by clang-format using chromium coding style:
//    clang-format -i -style=chromium filename
// DO NOT EDIT!

#ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_

void ActiveTexture(GLenum texture) { … }

void AttachShader(GLuint program, GLuint shader) { … }

void BindAttribLocationBucket(GLuint program,
                              GLuint index,
                              uint32_t name_bucket_id) { … }

void BindBuffer(GLenum target, GLuint buffer) { … }

void BindBufferBase(GLenum target, GLuint index, GLuint buffer) { … }

void BindBufferRange(GLenum target,
                     GLuint index,
                     GLuint buffer,
                     GLintptr offset,
                     GLsizeiptr size) { … }

void BindFramebuffer(GLenum target, GLuint framebuffer) { … }

void BindRenderbuffer(GLenum target, GLuint renderbuffer) { … }

void BindSampler(GLuint unit, GLuint sampler) { … }

void BindTexture(GLenum target, GLuint texture) { … }

void BindTransformFeedback(GLenum target, GLuint transformfeedback) { … }

void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { … }

void BlendEquation(GLenum mode) { … }

void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { … }

void BlendFunc(GLenum sfactor, GLenum dfactor) { … }

void BlendFuncSeparate(GLenum srcRGB,
                       GLenum dstRGB,
                       GLenum srcAlpha,
                       GLenum dstAlpha) { … }

void BufferData(GLenum target,
                GLsizeiptr size,
                uint32_t data_shm_id,
                uint32_t data_shm_offset,
                GLenum usage) { … }

void BufferSubData(GLenum target,
                   GLintptr offset,
                   GLsizeiptr size,
                   uint32_t data_shm_id,
                   uint32_t data_shm_offset) { … }

void CheckFramebufferStatus(GLenum target,
                            uint32_t result_shm_id,
                            uint32_t result_shm_offset) { … }

void Clear(GLbitfield mask) { … }

void ClearBufferfi(GLenum buffer,
                   GLint drawbuffers,
                   GLfloat depth,
                   GLint stencil) { … }

void ClearBufferfvImmediate(GLenum buffer,
                            GLint drawbuffers,
                            const GLfloat* value) { … }

void ClearBufferivImmediate(GLenum buffer,
                            GLint drawbuffers,
                            const GLint* value) { … }

void ClearBufferuivImmediate(GLenum buffer,
                             GLint drawbuffers,
                             const GLuint* value) { … }

void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { … }

void ClearDepthf(GLclampf depth) { … }

void ClearStencil(GLint s) { … }

void ClientWaitSync(GLuint sync,
                    GLbitfield flags,
                    GLuint64 timeout,
                    uint32_t result_shm_id,
                    uint32_t result_shm_offset) { … }

void ColorMask(GLboolean red,
               GLboolean green,
               GLboolean blue,
               GLboolean alpha) { … }

void CompileShader(GLuint shader) { … }

void CompressedTexImage2DBucket(GLenum target,
                                GLint level,
                                GLenum internalformat,
                                GLsizei width,
                                GLsizei height,
                                GLuint bucket_id) { … }

void CompressedTexImage2D(GLenum target,
                          GLint level,
                          GLenum internalformat,
                          GLsizei width,
                          GLsizei height,
                          GLsizei imageSize,
                          uint32_t data_shm_id,
                          uint32_t data_shm_offset) { … }

void CompressedTexSubImage2DBucket(GLenum target,
                                   GLint level,
                                   GLint xoffset,
                                   GLint yoffset,
                                   GLsizei width,
                                   GLsizei height,
                                   GLenum format,
                                   GLuint bucket_id) { … }

void CompressedTexSubImage2D(GLenum target,
                             GLint level,
                             GLint xoffset,
                             GLint yoffset,
                             GLsizei width,
                             GLsizei height,
                             GLenum format,
                             GLsizei imageSize,
                             uint32_t data_shm_id,
                             uint32_t data_shm_offset) { … }

void CompressedTexImage3DBucket(GLenum target,
                                GLint level,
                                GLenum internalformat,
                                GLsizei width,
                                GLsizei height,
                                GLsizei depth,
                                GLuint bucket_id) { … }

void CompressedTexImage3D(GLenum target,
                          GLint level,
                          GLenum internalformat,
                          GLsizei width,
                          GLsizei height,
                          GLsizei depth,
                          GLsizei imageSize,
                          uint32_t data_shm_id,
                          uint32_t data_shm_offset) { … }

void CompressedTexSubImage3DBucket(GLenum target,
                                   GLint level,
                                   GLint xoffset,
                                   GLint yoffset,
                                   GLint zoffset,
                                   GLsizei width,
                                   GLsizei height,
                                   GLsizei depth,
                                   GLenum format,
                                   GLuint bucket_id) { … }

void CompressedTexSubImage3D(GLenum target,
                             GLint level,
                             GLint xoffset,
                             GLint yoffset,
                             GLint zoffset,
                             GLsizei width,
                             GLsizei height,
                             GLsizei depth,
                             GLenum format,
                             GLsizei imageSize,
                             uint32_t data_shm_id,
                             uint32_t data_shm_offset) { … }

void CopyBufferSubData(GLenum readtarget,
                       GLenum writetarget,
                       GLintptr readoffset,
                       GLintptr writeoffset,
                       GLsizeiptr size) { … }

void CopyTexImage2D(GLenum target,
                    GLint level,
                    GLenum internalformat,
                    GLint x,
                    GLint y,
                    GLsizei width,
                    GLsizei height) { … }

void CopyTexSubImage2D(GLenum target,
                       GLint level,
                       GLint xoffset,
                       GLint yoffset,
                       GLint x,
                       GLint y,
                       GLsizei width,
                       GLsizei height) { … }

void CopyTexSubImage3D(GLenum target,
                       GLint level,
                       GLint xoffset,
                       GLint yoffset,
                       GLint zoffset,
                       GLint x,
                       GLint y,
                       GLsizei width,
                       GLsizei height) { … }

void CreateProgram(uint32_t client_id) { … }

void CreateShader(GLenum type, uint32_t client_id) { … }

void CullFace(GLenum mode) { … }

void DeleteBuffersImmediate(GLsizei n, const GLuint* buffers) { … }

void DeleteFramebuffersImmediate(GLsizei n, const GLuint* framebuffers) { … }

void DeleteProgram(GLuint program) { … }

void DeleteRenderbuffersImmediate(GLsizei n, const GLuint* renderbuffers) { … }

void DeleteSamplersImmediate(GLsizei n, const GLuint* samplers) { … }

void DeleteSync(GLuint sync) { … }

void DeleteShader(GLuint shader) { … }

void DeleteTexturesImmediate(GLsizei n, const GLuint* textures) { … }

void DeleteTransformFeedbacksImmediate(GLsizei n, const GLuint* ids) { … }

void DepthFunc(GLenum func) { … }

void DepthMask(GLboolean flag) { … }

void DepthRangef(GLclampf zNear, GLclampf zFar) { … }

void DetachShader(GLuint program, GLuint shader) { … }

void Disable(GLenum cap) { … }

void DisableVertexAttribArray(GLuint index) { … }

void DrawArrays(GLenum mode, GLint first, GLsizei count) { … }

void DrawElements(GLenum mode,
                  GLsizei count,
                  GLenum type,
                  GLuint index_offset) { … }

void Enable(GLenum cap) { … }

void EnableVertexAttribArray(GLuint index) { … }

void FenceSync(uint32_t client_id) { … }

void Finish() { … }

void Flush() { … }

void FramebufferRenderbuffer(GLenum target,
                             GLenum attachment,
                             GLenum renderbuffertarget,
                             GLuint renderbuffer) { … }

void FramebufferTexture2D(GLenum target,
                          GLenum attachment,
                          GLenum textarget,
                          GLuint texture,
                          GLint level) { … }

void FramebufferTextureLayer(GLenum target,
                             GLenum attachment,
                             GLuint texture,
                             GLint level,
                             GLint layer) { … }

void FrontFace(GLenum mode) { … }

void GenBuffersImmediate(GLsizei n, GLuint* buffers) { … }

void GenerateMipmap(GLenum target) { … }

void GenFramebuffersImmediate(GLsizei n, GLuint* framebuffers) { … }

void GenRenderbuffersImmediate(GLsizei n, GLuint* renderbuffers) { … }

void GenSamplersImmediate(GLsizei n, GLuint* samplers) { … }

void GenTexturesImmediate(GLsizei n, GLuint* textures) { … }

void GenTransformFeedbacksImmediate(GLsizei n, GLuint* ids) { … }

void GetActiveAttrib(GLuint program,
                     GLuint index,
                     uint32_t name_bucket_id,
                     uint32_t result_shm_id,
                     uint32_t result_shm_offset) { … }

void GetActiveUniform(GLuint program,
                      GLuint index,
                      uint32_t name_bucket_id,
                      uint32_t result_shm_id,
                      uint32_t result_shm_offset) { … }

void GetActiveUniformBlockiv(GLuint program,
                             GLuint index,
                             GLenum pname,
                             uint32_t params_shm_id,
                             uint32_t params_shm_offset) { … }

void GetActiveUniformBlockName(GLuint program,
                               GLuint index,
                               uint32_t name_bucket_id,
                               uint32_t result_shm_id,
                               uint32_t result_shm_offset) { … }

void GetActiveUniformsiv(GLuint program,
                         uint32_t indices_bucket_id,
                         GLenum pname,
                         uint32_t params_shm_id,
                         uint32_t params_shm_offset) { … }

void GetAttachedShaders(GLuint program,
                        uint32_t result_shm_id,
                        uint32_t result_shm_offset,
                        uint32_t result_size) { … }

void GetAttribLocation(GLuint program,
                       uint32_t name_bucket_id,
                       uint32_t location_shm_id,
                       uint32_t location_shm_offset) { … }

void GetBooleanv(GLenum pname,
                 uint32_t params_shm_id,
                 uint32_t params_shm_offset) { … }

void GetBooleani_v(GLenum pname,
                   GLuint index,
                   uint32_t data_shm_id,
                   uint32_t data_shm_offset) { … }

void GetBufferParameteri64v(GLenum target,
                            GLenum pname,
                            uint32_t params_shm_id,
                            uint32_t params_shm_offset) { … }

void GetBufferParameteriv(GLenum target,
                          GLenum pname,
                          uint32_t params_shm_id,
                          uint32_t params_shm_offset) { … }

void GetError(uint32_t result_shm_id, uint32_t result_shm_offset) { … }

void GetFloatv(GLenum pname,
               uint32_t params_shm_id,
               uint32_t params_shm_offset) { … }

void GetFragDataLocation(GLuint program,
                         uint32_t name_bucket_id,
                         uint32_t location_shm_id,
                         uint32_t location_shm_offset) { … }

void GetFramebufferAttachmentParameteriv(GLenum target,
                                         GLenum attachment,
                                         GLenum pname,
                                         uint32_t params_shm_id,
                                         uint32_t params_shm_offset) { … }

void GetInteger64v(GLenum pname,
                   uint32_t params_shm_id,
                   uint32_t params_shm_offset) { … }

void GetIntegeri_v(GLenum pname,
                   GLuint index,
                   uint32_t data_shm_id,
                   uint32_t data_shm_offset) { … }

void GetInteger64i_v(GLenum pname,
                     GLuint index,
                     uint32_t data_shm_id,
                     uint32_t data_shm_offset) { … }

void GetIntegerv(GLenum pname,
                 uint32_t params_shm_id,
                 uint32_t params_shm_offset) { … }

void GetInternalformativ(GLenum target,
                         GLenum format,
                         GLenum pname,
                         uint32_t params_shm_id,
                         uint32_t params_shm_offset) { … }

void GetProgramiv(GLuint program,
                  GLenum pname,
                  uint32_t params_shm_id,
                  uint32_t params_shm_offset) { … }

void GetProgramInfoLog(GLuint program, uint32_t bucket_id) { … }

void GetRenderbufferParameteriv(GLenum target,
                                GLenum pname,
                                uint32_t params_shm_id,
                                uint32_t params_shm_offset) { … }

void GetSamplerParameterfv(GLuint sampler,
                           GLenum pname,
                           uint32_t params_shm_id,
                           uint32_t params_shm_offset) { … }

void GetSamplerParameteriv(GLuint sampler,
                           GLenum pname,
                           uint32_t params_shm_id,
                           uint32_t params_shm_offset) { … }

void GetShaderiv(GLuint shader,
                 GLenum pname,
                 uint32_t params_shm_id,
                 uint32_t params_shm_offset) { … }

void GetShaderInfoLog(GLuint shader, uint32_t bucket_id) { … }

void GetShaderPrecisionFormat(GLenum shadertype,
                              GLenum precisiontype,
                              uint32_t result_shm_id,
                              uint32_t result_shm_offset) { … }

void GetShaderSource(GLuint shader, uint32_t bucket_id) { … }

void GetString(GLenum name, uint32_t bucket_id) { … }

void GetSynciv(GLuint sync,
               GLenum pname,
               uint32_t values_shm_id,
               uint32_t values_shm_offset) { … }

void GetTexParameterfv(GLenum target,
                       GLenum pname,
                       uint32_t params_shm_id,
                       uint32_t params_shm_offset) { … }

void GetTexParameteriv(GLenum target,
                       GLenum pname,
                       uint32_t params_shm_id,
                       uint32_t params_shm_offset) { … }

void GetTransformFeedbackVarying(GLuint program,
                                 GLuint index,
                                 uint32_t name_bucket_id,
                                 uint32_t result_shm_id,
                                 uint32_t result_shm_offset) { … }

void GetUniformBlockIndex(GLuint program,
                          uint32_t name_bucket_id,
                          uint32_t index_shm_id,
                          uint32_t index_shm_offset) { … }

void GetUniformfv(GLuint program,
                  GLint location,
                  uint32_t params_shm_id,
                  uint32_t params_shm_offset) { … }

void GetUniformiv(GLuint program,
                  GLint location,
                  uint32_t params_shm_id,
                  uint32_t params_shm_offset) { … }

void GetUniformuiv(GLuint program,
                   GLint location,
                   uint32_t params_shm_id,
                   uint32_t params_shm_offset) { … }

void GetUniformIndices(GLuint program,
                       uint32_t names_bucket_id,
                       uint32_t indices_shm_id,
                       uint32_t indices_shm_offset) { … }

void GetUniformLocation(GLuint program,
                        uint32_t name_bucket_id,
                        uint32_t location_shm_id,
                        uint32_t location_shm_offset) { … }

void GetVertexAttribfv(GLuint index,
                       GLenum pname,
                       uint32_t params_shm_id,
                       uint32_t params_shm_offset) { … }

void GetVertexAttribiv(GLuint index,
                       GLenum pname,
                       uint32_t params_shm_id,
                       uint32_t params_shm_offset) { … }

void GetVertexAttribIiv(GLuint index,
                        GLenum pname,
                        uint32_t params_shm_id,
                        uint32_t params_shm_offset) { … }

void GetVertexAttribIuiv(GLuint index,
                         GLenum pname,
                         uint32_t params_shm_id,
                         uint32_t params_shm_offset) { … }

void GetVertexAttribPointerv(GLuint index,
                             GLenum pname,
                             uint32_t pointer_shm_id,
                             uint32_t pointer_shm_offset) { … }

void Hint(GLenum target, GLenum mode) { … }

void InvalidateFramebufferImmediate(GLenum target,
                                    GLsizei count,
                                    const GLenum* attachments) { … }

void InvalidateSubFramebufferImmediate(GLenum target,
                                       GLsizei count,
                                       const GLenum* attachments,
                                       GLint x,
                                       GLint y,
                                       GLsizei width,
                                       GLsizei height) { … }

void IsBuffer(GLuint buffer,
              uint32_t result_shm_id,
              uint32_t result_shm_offset) { … }

void IsEnabled(GLenum cap, uint32_t result_shm_id, uint32_t result_shm_offset) { … }

void IsFramebuffer(GLuint framebuffer,
                   uint32_t result_shm_id,
                   uint32_t result_shm_offset) { … }

void IsProgram(GLuint program,
               uint32_t result_shm_id,
               uint32_t result_shm_offset) { … }

void IsRenderbuffer(GLuint renderbuffer,
                    uint32_t result_shm_id,
                    uint32_t result_shm_offset) { … }

void IsSampler(GLuint sampler,
               uint32_t result_shm_id,
               uint32_t result_shm_offset) { … }

void IsShader(GLuint shader,
              uint32_t result_shm_id,
              uint32_t result_shm_offset) { … }

void IsSync(GLuint sync, uint32_t result_shm_id, uint32_t result_shm_offset) { … }

void IsTexture(GLuint texture,
               uint32_t result_shm_id,
               uint32_t result_shm_offset) { … }

void IsTransformFeedback(GLuint transformfeedback,
                         uint32_t result_shm_id,
                         uint32_t result_shm_offset) { … }

void LineWidth(GLfloat width) { … }

void LinkProgram(GLuint program) { … }

void PauseTransformFeedback() { … }

void PixelStorei(GLenum pname, GLint param) { … }

void PolygonOffset(GLfloat factor, GLfloat units) { … }

void ReadBuffer(GLenum src) { … }

void ReadPixels(GLint x,
                GLint y,
                GLsizei width,
                GLsizei height,
                GLenum format,
                GLenum type,
                uint32_t pixels_shm_id,
                uint32_t pixels_shm_offset,
                uint32_t result_shm_id,
                uint32_t result_shm_offset,
                GLboolean async) { … }

void ReleaseShaderCompiler() { … }

void RenderbufferStorage(GLenum target,
                         GLenum internalformat,
                         GLsizei width,
                         GLsizei height) { … }

void ResumeTransformFeedback() { … }

void SampleCoverage(GLclampf value, GLboolean invert) { … }

void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) { … }

void SamplerParameterfvImmediate(GLuint sampler,
                                 GLenum pname,
                                 const GLfloat* params) { … }

void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) { … }

void SamplerParameterivImmediate(GLuint sampler,
                                 GLenum pname,
                                 const GLint* params) { … }

void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) { … }

void ShaderBinary(GLsizei n,
                  uint32_t shaders_shm_id,
                  uint32_t shaders_shm_offset,
                  GLenum binaryformat,
                  uint32_t binary_shm_id,
                  uint32_t binary_shm_offset,
                  GLsizei length) { … }

void ShaderSourceBucket(GLuint shader, uint32_t str_bucket_id) { … }

void MultiDrawBeginCHROMIUM(GLsizei drawcount) { … }

void MultiDrawEndCHROMIUM() { … }

void MultiDrawArraysCHROMIUM(GLenum mode,
                             uint32_t firsts_shm_id,
                             uint32_t firsts_shm_offset,
                             uint32_t counts_shm_id,
                             uint32_t counts_shm_offset,
                             GLsizei drawcount) { … }

void MultiDrawArraysInstancedCHROMIUM(GLenum mode,
                                      uint32_t firsts_shm_id,
                                      uint32_t firsts_shm_offset,
                                      uint32_t counts_shm_id,
                                      uint32_t counts_shm_offset,
                                      uint32_t instance_counts_shm_id,
                                      uint32_t instance_counts_shm_offset,
                                      GLsizei drawcount) { … }

void MultiDrawArraysInstancedBaseInstanceCHROMIUM(
    GLenum mode,
    uint32_t firsts_shm_id,
    uint32_t firsts_shm_offset,
    uint32_t counts_shm_id,
    uint32_t counts_shm_offset,
    uint32_t instance_counts_shm_id,
    uint32_t instance_counts_shm_offset,
    uint32_t baseinstances_shm_id,
    uint32_t baseinstances_shm_offset,
    GLsizei drawcount) { … }

void MultiDrawElementsCHROMIUM(GLenum mode,
                               uint32_t counts_shm_id,
                               uint32_t counts_shm_offset,
                               GLenum type,
                               uint32_t offsets_shm_id,
                               uint32_t offsets_shm_offset,
                               GLsizei drawcount) { … }

void MultiDrawElementsInstancedCHROMIUM(GLenum mode,
                                        uint32_t counts_shm_id,
                                        uint32_t counts_shm_offset,
                                        GLenum type,
                                        uint32_t offsets_shm_id,
                                        uint32_t offsets_shm_offset,
                                        uint32_t instance_counts_shm_id,
                                        uint32_t instance_counts_shm_offset,
                                        GLsizei drawcount) { … }

void MultiDrawElementsInstancedBaseVertexBaseInstanceCHROMIUM(
    GLenum mode,
    uint32_t counts_shm_id,
    uint32_t counts_shm_offset,
    GLenum type,
    uint32_t offsets_shm_id,
    uint32_t offsets_shm_offset,
    uint32_t instance_counts_shm_id,
    uint32_t instance_counts_shm_offset,
    uint32_t basevertices_shm_id,
    uint32_t basevertices_shm_offset,
    uint32_t baseinstances_shm_id,
    uint32_t baseinstances_shm_offset,
    GLsizei drawcount) { … }

void StencilFunc(GLenum func, GLint ref, GLuint mask) { … }

void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { … }

void StencilMask(GLuint mask) { … }

void StencilMaskSeparate(GLenum face, GLuint mask) { … }

void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) { … }

void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { … }

void TexImage2D(GLenum target,
                GLint level,
                GLint internalformat,
                GLsizei width,
                GLsizei height,
                GLenum format,
                GLenum type,
                uint32_t pixels_shm_id,
                uint32_t pixels_shm_offset) { … }

void TexImage3D(GLenum target,
                GLint level,
                GLint internalformat,
                GLsizei width,
                GLsizei height,
                GLsizei depth,
                GLenum format,
                GLenum type,
                uint32_t pixels_shm_id,
                uint32_t pixels_shm_offset) { … }

void TexParameterf(GLenum target, GLenum pname, GLfloat param) { … }

void TexParameterfvImmediate(GLenum target,
                             GLenum pname,
                             const GLfloat* params) { … }

void TexParameteri(GLenum target, GLenum pname, GLint param) { … }

void TexParameterivImmediate(GLenum target, GLenum pname, const GLint* params) { … }

void TexStorage3D(GLenum target,
                  GLsizei levels,
                  GLenum internalFormat,
                  GLsizei width,
                  GLsizei height,
                  GLsizei depth) { … }

void TexSubImage2D(GLenum target,
                   GLint level,
                   GLint xoffset,
                   GLint yoffset,
                   GLsizei width,
                   GLsizei height,
                   GLenum format,
                   GLenum type,
                   uint32_t pixels_shm_id,
                   uint32_t pixels_shm_offset,
                   GLboolean internal) { … }

void TexSubImage3D(GLenum target,
                   GLint level,
                   GLint xoffset,
                   GLint yoffset,
                   GLint zoffset,
                   GLsizei width,
                   GLsizei height,
                   GLsizei depth,
                   GLenum format,
                   GLenum type,
                   uint32_t pixels_shm_id,
                   uint32_t pixels_shm_offset,
                   GLboolean internal) { … }

void TransformFeedbackVaryingsBucket(GLuint program,
                                     uint32_t varyings_bucket_id,
                                     GLenum buffermode) { … }

void Uniform1f(GLint location, GLfloat x) { … }

void Uniform1fvImmediate(GLint location, GLsizei count, const GLfloat* v) { … }

void Uniform1i(GLint location, GLint x) { … }

void Uniform1ivImmediate(GLint location, GLsizei count, const GLint* v) { … }

void Uniform1ui(GLint location, GLuint x) { … }

void Uniform1uivImmediate(GLint location, GLsizei count, const GLuint* v) { … }

void Uniform2f(GLint location, GLfloat x, GLfloat y) { … }

void Uniform2fvImmediate(GLint location, GLsizei count, const GLfloat* v) { … }

void Uniform2i(GLint location, GLint x, GLint y) { … }

void Uniform2ivImmediate(GLint location, GLsizei count, const GLint* v) { … }

void Uniform2ui(GLint location, GLuint x, GLuint y) { … }

void Uniform2uivImmediate(GLint location, GLsizei count, const GLuint* v) { … }

void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { … }

void Uniform3fvImmediate(GLint location, GLsizei count, const GLfloat* v) { … }

void Uniform3i(GLint location, GLint x, GLint y, GLint z) { … }

void Uniform3ivImmediate(GLint location, GLsizei count, const GLint* v) { … }

void Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) { … }

void Uniform3uivImmediate(GLint location, GLsizei count, const GLuint* v) { … }

void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { … }

void Uniform4fvImmediate(GLint location, GLsizei count, const GLfloat* v) { … }

void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) { … }

void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) { … }

void Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w) { … }

void Uniform4uivImmediate(GLint location, GLsizei count, const GLuint* v) { … }

void UniformBlockBinding(GLuint program, GLuint index, GLuint binding) { … }

void UniformMatrix2fvImmediate(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat* value) { … }

void UniformMatrix2x3fvImmediate(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat* value) { … }

void UniformMatrix2x4fvImmediate(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat* value) { … }

void UniformMatrix3fvImmediate(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat* value) { … }

void UniformMatrix3x2fvImmediate(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat* value) { … }

void UniformMatrix3x4fvImmediate(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat* value) { … }

void UniformMatrix4fvImmediate(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat* value) { … }

void UniformMatrix4x2fvImmediate(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat* value) { … }

void UniformMatrix4x3fvImmediate(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat* value) { … }

void UseProgram(GLuint program) { … }

void ValidateProgram(GLuint program) { … }

void VertexAttrib1f(GLuint indx, GLfloat x) { … }

void VertexAttrib1fvImmediate(GLuint indx, const GLfloat* values) { … }

void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { … }

void VertexAttrib2fvImmediate(GLuint indx, const GLfloat* values) { … }

void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { … }

void VertexAttrib3fvImmediate(GLuint indx, const GLfloat* values) { … }

void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { … }

void VertexAttrib4fvImmediate(GLuint indx, const GLfloat* values) { … }

void VertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) { … }

void VertexAttribI4ivImmediate(GLuint indx, const GLint* values) { … }

void VertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w) { … }

void VertexAttribI4uivImmediate(GLuint indx, const GLuint* values) { … }

void VertexAttribIPointer(GLuint indx,
                          GLint size,
                          GLenum type,
                          GLsizei stride,
                          GLuint offset) { … }

void VertexAttribPointer(GLuint indx,
                         GLint size,
                         GLenum type,
                         GLboolean normalized,
                         GLsizei stride,
                         GLuint offset) { … }

void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) { … }

void WaitSync(GLuint sync, GLbitfield flags, GLuint64 timeout) { … }

void BlitFramebufferCHROMIUM(GLint srcX0,
                             GLint srcY0,
                             GLint srcX1,
                             GLint srcY1,
                             GLint dstX0,
                             GLint dstY0,
                             GLint dstX1,
                             GLint dstY1,
                             GLbitfield mask,
                             GLenum filter) { … }

void RenderbufferStorageMultisampleCHROMIUM(GLenum target,
                                            GLsizei samples,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height) { … }

void RenderbufferStorageMultisampleAdvancedAMD(GLenum target,
                                               GLsizei samples,
                                               GLsizei storageSamples,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height) { … }

void RenderbufferStorageMultisampleEXT(GLenum target,
                                       GLsizei samples,
                                       GLenum internalformat,
                                       GLsizei width,
                                       GLsizei height) { … }

void FramebufferTexture2DMultisampleEXT(GLenum target,
                                        GLenum attachment,
                                        GLenum textarget,
                                        GLuint texture,
                                        GLint level,
                                        GLsizei samples) { … }

void TexStorage2DEXT(GLenum target,
                     GLsizei levels,
                     GLenum internalFormat,
                     GLsizei width,
                     GLsizei height) { … }

void GenQueriesEXTImmediate(GLsizei n, GLuint* queries) { … }

void DeleteQueriesEXTImmediate(GLsizei n, const GLuint* queries) { … }

void QueryCounterEXT(GLuint id,
                     GLenum target,
                     uint32_t sync_data_shm_id,
                     uint32_t sync_data_shm_offset,
                     GLuint submit_count) { … }

void BeginQueryEXT(GLenum target,
                   GLuint id,
                   uint32_t sync_data_shm_id,
                   uint32_t sync_data_shm_offset) { … }

void BeginTransformFeedback(GLenum primitivemode) { … }

void EndQueryEXT(GLenum target, GLuint submit_count) { … }

void EndTransformFeedback() { … }

void SetDisjointValueSyncCHROMIUM(uint32_t sync_data_shm_id,
                                  uint32_t sync_data_shm_offset) { … }

void InsertEventMarkerEXT(GLuint bucket_id) { … }

void PushGroupMarkerEXT(GLuint bucket_id) { … }

void PopGroupMarkerEXT() { … }

void GenVertexArraysOESImmediate(GLsizei n, GLuint* arrays) { … }

void DeleteVertexArraysOESImmediate(GLsizei n, const GLuint* arrays) { … }

void IsVertexArrayOES(GLuint array,
                      uint32_t result_shm_id,
                      uint32_t result_shm_offset) { … }

void BindVertexArrayOES(GLuint array) { … }

void FramebufferParameteri(GLenum target, GLenum pname, GLint param) { … }

void BindImageTexture(GLuint unit,
                      GLuint texture,
                      GLint level,
                      GLboolean layered,
                      GLint layer,
                      GLenum access,
                      GLenum format) { … }

void DispatchCompute(GLuint num_groups_x,
                     GLuint num_groups_y,
                     GLuint num_groups_z) { … }

void DispatchComputeIndirect(GLintptr offset) { … }

void DrawArraysIndirect(GLenum mode, GLuint offset) { … }

void DrawElementsIndirect(GLenum mode, GLenum type, GLuint offset) { … }

void GetProgramInterfaceiv(GLuint program,
                           GLenum program_interface,
                           GLenum pname,
                           uint32_t params_shm_id,
                           uint32_t params_shm_offset) { … }

void GetProgramResourceIndex(GLuint program,
                             GLenum program_interface,
                             uint32_t name_bucket_id,
                             uint32_t index_shm_id,
                             uint32_t index_shm_offset) { … }

void GetProgramResourceName(GLuint program,
                            GLenum program_interface,
                            GLuint index,
                            uint32_t name_bucket_id,
                            uint32_t result_shm_id,
                            uint32_t result_shm_offset) { … }

void GetProgramResourceiv(GLuint program,
                          GLenum program_interface,
                          GLuint index,
                          uint32_t props_bucket_id,
                          uint32_t params_shm_id,
                          uint32_t params_shm_offset) { … }

void GetProgramResourceLocation(GLuint program,
                                GLenum program_interface,
                                uint32_t name_bucket_id,
                                uint32_t location_shm_id,
                                uint32_t location_shm_offset) { … }

void MemoryBarrierEXT(GLbitfield barriers) { … }

void MemoryBarrierByRegion(GLbitfield barriers) { … }

void SwapBuffers(GLuint64 swap_id, GLbitfield flags) { … }

void GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
                                 GLsizei count,
                                 GLenum type,
                                 GLuint offset,
                                 uint32_t result_shm_id,
                                 uint32_t result_shm_offset) { … }

void EnableFeatureCHROMIUM(GLuint bucket_id,
                           uint32_t result_shm_id,
                           uint32_t result_shm_offset) { … }

void MapBufferRange(GLenum target,
                    GLintptr offset,
                    GLsizeiptr size,
                    GLbitfield access,
                    uint32_t data_shm_id,
                    uint32_t data_shm_offset,
                    uint32_t result_shm_id,
                    uint32_t result_shm_offset) { … }

void UnmapBuffer(GLenum target) { … }

void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr size) { … }

void ResizeCHROMIUM(GLint width,
                    GLint height,
                    GLfloat scale_factor,
                    GLboolean alpha,
                    GLuint shm_id,
                    GLuint shm_offset,
                    GLsizei color_space_size) { … }

void GetRequestableExtensionsCHROMIUM(uint32_t bucket_id) { … }

void RequestExtensionCHROMIUM(uint32_t bucket_id) { … }

void GetProgramInfoCHROMIUM(GLuint program, uint32_t bucket_id) { … }

void GetUniformBlocksCHROMIUM(GLuint program, uint32_t bucket_id) { … }

void GetTransformFeedbackVaryingsCHROMIUM(GLuint program, uint32_t bucket_id) { … }

void GetUniformsES3CHROMIUM(GLuint program, uint32_t bucket_id) { … }

void DescheduleUntilFinishedCHROMIUM() { … }

void GetTranslatedShaderSourceANGLE(GLuint shader, uint32_t bucket_id) { … }

void CopyTextureCHROMIUM(GLuint source_id,
                         GLint source_level,
                         GLenum dest_target,
                         GLuint dest_id,
                         GLint dest_level,
                         GLint internalformat,
                         GLenum dest_type,
                         GLboolean unpack_flip_y,
                         GLboolean unpack_premultiply_alpha,
                         GLboolean unpack_unmultiply_alpha) { … }

void CopySubTextureCHROMIUM(GLuint source_id,
                            GLint source_level,
                            GLenum dest_target,
                            GLuint dest_id,
                            GLint dest_level,
                            GLint xoffset,
                            GLint yoffset,
                            GLint x,
                            GLint y,
                            GLsizei width,
                            GLsizei height,
                            GLboolean unpack_flip_y,
                            GLboolean unpack_premultiply_alpha,
                            GLboolean unpack_unmultiply_alpha) { … }

void DrawArraysInstancedANGLE(GLenum mode,
                              GLint first,
                              GLsizei count,
                              GLsizei primcount) { … }

void DrawArraysInstancedBaseInstanceANGLE(GLenum mode,
                                          GLint first,
                                          GLsizei count,
                                          GLsizei primcount,
                                          GLuint baseinstance) { … }

void DrawElementsInstancedANGLE(GLenum mode,
                                GLsizei count,
                                GLenum type,
                                GLuint index_offset,
                                GLsizei primcount) { … }

void DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
                                                      GLsizei count,
                                                      GLenum type,
                                                      GLuint index_offset,
                                                      GLsizei primcount,
                                                      GLint basevertex,
                                                      GLuint baseinstance) { … }

void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) { … }

void BindUniformLocationCHROMIUMBucket(GLuint program,
                                       GLint location,
                                       uint32_t name_bucket_id) { … }

void TraceBeginCHROMIUM(GLuint category_bucket_id, GLuint name_bucket_id) { … }

void TraceEndCHROMIUM() { … }

void DiscardFramebufferEXTImmediate(GLenum target,
                                    GLsizei count,
                                    const GLenum* attachments) { … }

void LoseContextCHROMIUM(GLenum current, GLenum other) { … }

void DrawBuffersEXTImmediate(GLsizei count, const GLenum* bufs) { … }

void FlushDriverCachesCHROMIUM() { … }

void SetActiveURLCHROMIUM(GLuint url_bucket_id) { … }

void ContextVisibilityHintCHROMIUM(GLboolean visibility) { … }

void BlendBarrierKHR() { … }

void BindFragDataLocationIndexedEXTBucket(GLuint program,
                                          GLuint colorNumber,
                                          GLuint index,
                                          uint32_t name_bucket_id) { … }

void BindFragDataLocationEXTBucket(GLuint program,
                                   GLuint colorNumber,
                                   uint32_t name_bucket_id) { … }

void GetFragDataIndexEXT(GLuint program,
                         uint32_t name_bucket_id,
                         uint32_t index_shm_id,
                         uint32_t index_shm_offset) { … }

void InitializeDiscardableTextureCHROMIUM(GLuint texture_id,
                                          uint32_t shm_id,
                                          uint32_t shm_offset) { … }

void UnlockDiscardableTextureCHROMIUM(GLuint texture_id) { … }

void LockDiscardableTextureCHROMIUM(GLuint texture_id) { … }

void WindowRectanglesEXTImmediate(GLenum mode,
                                  GLsizei count,
                                  const GLint* box) { … }

void CreateGpuFenceINTERNAL(GLuint gpu_fence_id) { … }

void WaitGpuFenceCHROMIUM(GLuint gpu_fence_id) { … }

void DestroyGpuFenceCHROMIUM(GLuint gpu_fence_id) { … }

void SetReadbackBufferShadowAllocationINTERNAL(GLuint buffer_id,
                                               GLint shm_id,
                                               GLuint shm_offset,
                                               GLuint size) { … }

void FramebufferTextureMultiviewOVR(GLenum target,
                                    GLenum attachment,
                                    GLuint texture,
                                    GLint level,
                                    GLint baseViewIndex,
                                    GLsizei numViews) { … }

void MaxShaderCompilerThreadsKHR(GLuint count) { … }

void CreateAndTexStorage2DSharedImageINTERNALImmediate(GLuint texture,
                                                       const GLbyte* mailbox) { … }

void BeginSharedImageAccessDirectCHROMIUM(GLuint texture, GLenum mode) { … }

void EndSharedImageAccessDirectCHROMIUM(GLuint texture) { … }

void ConvertRGBAToYUVAMailboxesINTERNALImmediate(GLenum planes_yuv_color_space,
                                                 GLenum plane_config,
                                                 GLenum subsampling,
                                                 const GLbyte* mailboxes) { … }

void ConvertYUVAMailboxesToRGBINTERNALImmediate(GLint src_x,
                                                GLint src_y,
                                                GLsizei width,
                                                GLsizei height,
                                                GLenum planes_yuv_color_space,
                                                GLenum plane_config,
                                                GLenum subsampling,
                                                const GLbyte* mailboxes) { … }

void ConvertYUVAMailboxesToTextureINTERNALImmediate(
    GLuint texture,
    GLenum target,
    GLuint internal_format,
    GLenum type,
    GLint src_x,
    GLint src_y,
    GLsizei width,
    GLsizei height,
    GLboolean flip_y,
    GLenum planes_yuv_color_space,
    GLenum plane_config,
    GLenum subsampling,
    const GLbyte* mailboxes) { … }

void CopySharedImageINTERNALImmediate(GLint xoffset,
                                      GLint yoffset,
                                      GLint x,
                                      GLint y,
                                      GLsizei width,
                                      GLsizei height,
                                      GLboolean unpack_flip_y,
                                      const GLbyte* mailboxes) { … }

void CopySharedImageToTextureINTERNALImmediate(GLuint texture,
                                               GLenum target,
                                               GLuint internal_format,
                                               GLenum type,
                                               GLint src_x,
                                               GLint src_y,
                                               GLsizei width,
                                               GLsizei height,
                                               GLboolean flip_y,
                                               const GLbyte* src_mailbox) { … }

void ReadbackARGBImagePixelsINTERNAL(GLint src_x,
                                     GLint src_y,
                                     GLint plane_index,
                                     GLuint dst_width,
                                     GLuint dst_height,
                                     GLuint row_bytes,
                                     GLuint dst_sk_color_type,
                                     GLuint dst_sk_alpha_type,
                                     GLint shm_id,
                                     GLuint shm_offset,
                                     GLuint color_space_offset,
                                     GLuint pixels_offset,
                                     GLuint mailbox_offset) { … }

void WritePixelsYUVINTERNAL(GLuint src_width,
                            GLuint src_height,
                            GLuint src_row_bytes_plane1,
                            GLuint src_row_bytes_plane2,
                            GLuint src_row_bytes_plane3,
                            GLuint src_row_bytes_plane4,
                            GLuint src_yuv_plane_config,
                            GLuint src_yuv_subsampling,
                            GLuint src_yuv_datatype,
                            GLint shm_id,
                            GLuint shm_offset,
                            GLuint pixels_offset_plane1,
                            GLuint pixels_offset_plane2,
                            GLuint pixels_offset_plane3,
                            GLuint pixels_offset_plane4) { … }

void EnableiOES(GLenum target, GLuint index) { … }

void DisableiOES(GLenum target, GLuint index) { … }

void BlendEquationiOES(GLuint buf, GLenum mode) { … }

void BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha) { … }

void BlendFunciOES(GLuint buf, GLenum src, GLenum dst) { … }

void BlendFuncSeparateiOES(GLuint buf,
                           GLenum srcRGB,
                           GLenum dstRGB,
                           GLenum srcAlpha,
                           GLenum dstAlpha) { … }

void ColorMaskiOES(GLuint buf,
                   GLboolean r,
                   GLboolean g,
                   GLboolean b,
                   GLboolean a) { … }

void IsEnablediOES(GLenum target,
                   GLuint index,
                   uint32_t result_shm_id,
                   uint32_t result_shm_offset) { … }

void ProvokingVertexANGLE(GLenum provokeMode) { … }

void FramebufferMemorylessPixelLocalStorageANGLE(GLint plane,
                                                 GLenum internalformat) { … }

void FramebufferTexturePixelLocalStorageANGLE(GLint plane,
                                              GLuint backingtexture,
                                              GLint level,
                                              GLint layer) { … }

void FramebufferPixelLocalClearValuefvANGLEImmediate(GLint plane,
                                                     const GLfloat* value) { … }

void FramebufferPixelLocalClearValueivANGLEImmediate(GLint plane,
                                                     const GLint* value) { … }

void FramebufferPixelLocalClearValueuivANGLEImmediate(GLint plane,
                                                      const GLuint* value) { … }

void BeginPixelLocalStorageANGLEImmediate(GLsizei count,
                                          const GLenum* loadops) { … }

void EndPixelLocalStorageANGLEImmediate(GLsizei count, const GLenum* storeops) { … }

void PixelLocalStorageBarrierANGLE() { … }

void FramebufferPixelLocalStorageInterruptANGLE() { … }

void FramebufferPixelLocalStorageRestoreANGLE() { … }

void GetFramebufferPixelLocalStorageParameterfvANGLE(
    GLint plane,
    GLenum pname,
    uint32_t params_shm_id,
    uint32_t params_shm_offset) { … }

void GetFramebufferPixelLocalStorageParameterivANGLE(
    GLint plane,
    GLenum pname,
    uint32_t params_shm_id,
    uint32_t params_shm_offset) { … }

void ClipControlEXT(GLenum origin, GLenum depth) { … }

void PolygonModeANGLE(GLenum face, GLenum mode) { … }

void PolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp) { … }

#endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_