chromium/gpu/command_buffer/client/gles2_implementation_impl_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!

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

// This file is included by gles2_implementation.cc to define the
// GL api functions.
#ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_IMPL_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_IMPL_AUTOGEN_H_

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

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

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

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

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

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

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

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

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

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

void GLES2Implementation::BlendEquation(GLenum mode) { … }

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

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

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

GLenum GLES2Implementation::CheckFramebufferStatus(GLenum target) { … }

void GLES2Implementation::Clear(GLbitfield mask) { … }

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

void GLES2Implementation::ClearBufferfv(GLenum buffer,
                                        GLint drawbuffers,
                                        const GLfloat* value) { … }

void GLES2Implementation::ClearBufferiv(GLenum buffer,
                                        GLint drawbuffers,
                                        const GLint* value) { … }

void GLES2Implementation::ClearBufferuiv(GLenum buffer,
                                         GLint drawbuffers,
                                         const GLuint* value) { … }

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

void GLES2Implementation::ClearDepthf(GLclampf depth) { … }

void GLES2Implementation::ClearStencil(GLint s) { … }

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

void GLES2Implementation::CompileShader(GLuint shader) { … }

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

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

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

GLuint GLES2Implementation::CreateProgram() { … }

GLuint GLES2Implementation::CreateShader(GLenum type) { … }

void GLES2Implementation::CullFace(GLenum mode) { … }

void GLES2Implementation::DeleteBuffers(GLsizei n, const GLuint* buffers) { … }

void GLES2Implementation::DeleteFramebuffers(GLsizei n,
                                             const GLuint* framebuffers) { … }

void GLES2Implementation::DeleteProgram(GLuint program) { … }

void GLES2Implementation::DeleteRenderbuffers(GLsizei n,
                                              const GLuint* renderbuffers) { … }

void GLES2Implementation::DeleteSamplers(GLsizei n, const GLuint* samplers) { … }

void GLES2Implementation::DeleteSync(GLsync sync) { … }

void GLES2Implementation::DeleteShader(GLuint shader) { … }

void GLES2Implementation::DeleteTextures(GLsizei n, const GLuint* textures) { … }

void GLES2Implementation::DeleteTransformFeedbacks(GLsizei n,
                                                   const GLuint* ids) { … }

void GLES2Implementation::DepthFunc(GLenum func) { … }

void GLES2Implementation::DepthMask(GLboolean flag) { … }

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

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

GLsync GLES2Implementation::FenceSync(GLenum condition, GLbitfield flags) { … }

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

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

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

void GLES2Implementation::FrontFace(GLenum mode) { … }

void GLES2Implementation::GenBuffers(GLsizei n, GLuint* buffers) { … }

void GLES2Implementation::GenerateMipmap(GLenum target) { … }

void GLES2Implementation::GenFramebuffers(GLsizei n, GLuint* framebuffers) { … }

void GLES2Implementation::GenRenderbuffers(GLsizei n, GLuint* renderbuffers) { … }

void GLES2Implementation::GenSamplers(GLsizei n, GLuint* samplers) { … }

void GLES2Implementation::GenTextures(GLsizei n, GLuint* textures) { … }

void GLES2Implementation::GenTransformFeedbacks(GLsizei n, GLuint* ids) { … }

void GLES2Implementation::GetBooleanv(GLenum pname, GLboolean* params) { … }
void GLES2Implementation::GetBooleani_v(GLenum pname,
                                        GLuint index,
                                        GLboolean* data) { … }
void GLES2Implementation::GetBufferParameteri64v(GLenum target,
                                                 GLenum pname,
                                                 GLint64* params) { … }
void GLES2Implementation::GetBufferParameteriv(GLenum target,
                                               GLenum pname,
                                               GLint* params) { … }
void GLES2Implementation::GetFloatv(GLenum pname, GLfloat* params) { … }
void GLES2Implementation::GetFramebufferAttachmentParameteriv(GLenum target,
                                                              GLenum attachment,
                                                              GLenum pname,
                                                              GLint* params) { … }
void GLES2Implementation::GetInteger64v(GLenum pname, GLint64* params) { … }
void GLES2Implementation::GetIntegeri_v(GLenum pname,
                                        GLuint index,
                                        GLint* data) { … }
void GLES2Implementation::GetInteger64i_v(GLenum pname,
                                          GLuint index,
                                          GLint64* data) { … }
void GLES2Implementation::GetIntegerv(GLenum pname, GLint* params) { … }
void GLES2Implementation::GetProgramiv(GLuint program,
                                       GLenum pname,
                                       GLint* params) { … }
void GLES2Implementation::GetProgramInfoLog(GLuint program,
                                            GLsizei bufsize,
                                            GLsizei* length,
                                            char* infolog) { … }
void GLES2Implementation::GetRenderbufferParameteriv(GLenum target,
                                                     GLenum pname,
                                                     GLint* params) { … }
void GLES2Implementation::GetSamplerParameterfv(GLuint sampler,
                                                GLenum pname,
                                                GLfloat* params) { … }
void GLES2Implementation::GetSamplerParameteriv(GLuint sampler,
                                                GLenum pname,
                                                GLint* params) { … }
void GLES2Implementation::GetShaderiv(GLuint shader,
                                      GLenum pname,
                                      GLint* params) { … }
void GLES2Implementation::GetShaderInfoLog(GLuint shader,
                                           GLsizei bufsize,
                                           GLsizei* length,
                                           char* infolog) { … }
void GLES2Implementation::GetShaderSource(GLuint shader,
                                          GLsizei bufsize,
                                          GLsizei* length,
                                          char* source) { … }
void GLES2Implementation::GetSynciv(GLsync sync,
                                    GLenum pname,
                                    GLsizei bufsize,
                                    GLsizei* length,
                                    GLint* values) { … }
void GLES2Implementation::GetTexParameterfv(GLenum target,
                                            GLenum pname,
                                            GLfloat* params) { … }
void GLES2Implementation::GetTexParameteriv(GLenum target,
                                            GLenum pname,
                                            GLint* params) { … }
void GLES2Implementation::Hint(GLenum target, GLenum mode) { … }

void GLES2Implementation::InvalidateFramebuffer(GLenum target,
                                                GLsizei count,
                                                const GLenum* attachments) { … }

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

GLboolean GLES2Implementation::IsBuffer(GLuint buffer) { … }

GLboolean GLES2Implementation::IsFramebuffer(GLuint framebuffer) { … }

GLboolean GLES2Implementation::IsProgram(GLuint program) { … }

GLboolean GLES2Implementation::IsRenderbuffer(GLuint renderbuffer) { … }

GLboolean GLES2Implementation::IsSampler(GLuint sampler) { … }

GLboolean GLES2Implementation::IsShader(GLuint shader) { … }

GLboolean GLES2Implementation::IsSync(GLsync sync) { … }

GLboolean GLES2Implementation::IsTexture(GLuint texture) { … }

GLboolean GLES2Implementation::IsTransformFeedback(GLuint transformfeedback) { … }

void GLES2Implementation::LineWidth(GLfloat width) { … }

void GLES2Implementation::PauseTransformFeedback() { … }

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

void GLES2Implementation::ReadBuffer(GLenum src) { … }

void GLES2Implementation::ReleaseShaderCompiler() { … }

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

void GLES2Implementation::ResumeTransformFeedback() { … }

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

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

void GLES2Implementation::SamplerParameterfv(GLuint sampler,
                                             GLenum pname,
                                             const GLfloat* params) { … }

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

void GLES2Implementation::SamplerParameteriv(GLuint sampler,
                                             GLenum pname,
                                             const GLint* params) { … }

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

void GLES2Implementation::ShaderSource(GLuint shader,
                                       GLsizei count,
                                       const GLchar* const* str,
                                       const GLint* length) { … }

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

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

void GLES2Implementation::StencilMask(GLuint mask) { … }

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

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

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

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

void GLES2Implementation::TexParameterfv(GLenum target,
                                         GLenum pname,
                                         const GLfloat* params) { … }

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

void GLES2Implementation::TexParameteriv(GLenum target,
                                         GLenum pname,
                                         const GLint* params) { … }

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

void GLES2Implementation::TransformFeedbackVaryings(GLuint program,
                                                    GLsizei count,
                                                    const char* const* varyings,
                                                    GLenum buffermode) { … }

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

void GLES2Implementation::Uniform1fv(GLint location,
                                     GLsizei count,
                                     const GLfloat* v) { … }

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

void GLES2Implementation::Uniform1iv(GLint location,
                                     GLsizei count,
                                     const GLint* v) { … }

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

void GLES2Implementation::Uniform1uiv(GLint location,
                                      GLsizei count,
                                      const GLuint* v) { … }

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

void GLES2Implementation::Uniform2fv(GLint location,
                                     GLsizei count,
                                     const GLfloat* v) { … }

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

void GLES2Implementation::Uniform2iv(GLint location,
                                     GLsizei count,
                                     const GLint* v) { … }

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

void GLES2Implementation::Uniform2uiv(GLint location,
                                      GLsizei count,
                                      const GLuint* v) { … }

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

void GLES2Implementation::Uniform3fv(GLint location,
                                     GLsizei count,
                                     const GLfloat* v) { … }

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

void GLES2Implementation::Uniform3iv(GLint location,
                                     GLsizei count,
                                     const GLint* v) { … }

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

void GLES2Implementation::Uniform3uiv(GLint location,
                                      GLsizei count,
                                      const GLuint* v) { … }

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

void GLES2Implementation::Uniform4fv(GLint location,
                                     GLsizei count,
                                     const GLfloat* v) { … }

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

void GLES2Implementation::Uniform4iv(GLint location,
                                     GLsizei count,
                                     const GLint* v) { … }

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

void GLES2Implementation::Uniform4uiv(GLint location,
                                      GLsizei count,
                                      const GLuint* v) { … }

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

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

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

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

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

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

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

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

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

void GLES2Implementation::UseProgram(GLuint program) { … }

void GLES2Implementation::ValidateProgram(GLuint program) { … }

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

void GLES2Implementation::VertexAttrib1fv(GLuint indx, const GLfloat* values) { … }

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

void GLES2Implementation::VertexAttrib2fv(GLuint indx, const GLfloat* values) { … }

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

void GLES2Implementation::VertexAttrib3fv(GLuint indx, const GLfloat* values) { … }

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

void GLES2Implementation::VertexAttrib4fv(GLuint indx, const GLfloat* values) { … }

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

void GLES2Implementation::VertexAttribI4iv(GLuint indx, const GLint* values) { … }

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

void GLES2Implementation::VertexAttribI4uiv(GLuint indx, const GLuint* values) { … }

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

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

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

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

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

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

void GLES2Implementation::GenQueriesEXT(GLsizei n, GLuint* queries) { … }

void GLES2Implementation::DeleteQueriesEXT(GLsizei n, const GLuint* queries) { … }

void GLES2Implementation::BeginTransformFeedback(GLenum primitivemode) { … }

void GLES2Implementation::EndTransformFeedback() { … }

void GLES2Implementation::GenVertexArraysOES(GLsizei n, GLuint* arrays) { … }

void GLES2Implementation::DeleteVertexArraysOES(GLsizei n,
                                                const GLuint* arrays) { … }

GLboolean GLES2Implementation::IsVertexArrayOES(GLuint array) { … }

void GLES2Implementation::BindVertexArrayOES(GLuint array) { … }

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

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

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

void GLES2Implementation::DispatchComputeIndirect(GLintptr offset) { … }

void GLES2Implementation::GetProgramInterfaceiv(GLuint program,
                                                GLenum program_interface,
                                                GLenum pname,
                                                GLint* params) { … }
void GLES2Implementation::MemoryBarrierEXT(GLbitfield barriers) { … }

void GLES2Implementation::MemoryBarrierByRegion(GLbitfield barriers) { … }

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

void GLES2Implementation::DescheduleUntilFinishedCHROMIUM() { … }

void GLES2Implementation::GetTranslatedShaderSourceANGLE(GLuint shader,
                                                         GLsizei bufsize,
                                                         GLsizei* length,
                                                         char* source) { … }
void GLES2Implementation::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 GLES2Implementation::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 GLES2Implementation::DiscardFramebufferEXT(GLenum target,
                                                GLsizei count,
                                                const GLenum* attachments) { … }

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

void GLES2Implementation::DrawBuffersEXT(GLsizei count, const GLenum* bufs) { … }

void GLES2Implementation::FlushDriverCachesCHROMIUM() { … }

void GLES2Implementation::ContextVisibilityHintCHROMIUM(GLboolean visibility) { … }

void GLES2Implementation::BlendBarrierKHR() { … }

void GLES2Implementation::WindowRectanglesEXT(GLenum mode,
                                              GLsizei count,
                                              const GLint* box) { … }

void GLES2Implementation::WaitGpuFenceCHROMIUM(GLuint gpu_fence_id) { … }

void GLES2Implementation::DestroyGpuFenceCHROMIUM(GLuint gpu_fence_id) { … }

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

void GLES2Implementation::MaxShaderCompilerThreadsKHR(GLuint count) { … }

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

void GLES2Implementation::EndSharedImageAccessDirectCHROMIUM(GLuint texture) { … }

void GLES2Implementation::ConvertRGBAToYUVAMailboxesINTERNAL(
    GLenum planes_yuv_color_space,
    GLenum plane_config,
    GLenum subsampling,
    const GLbyte* mailboxes) { … }

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

void GLES2Implementation::ConvertYUVAMailboxesToTextureINTERNAL(
    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 GLES2Implementation::CopySharedImageINTERNAL(GLint xoffset,
                                                  GLint yoffset,
                                                  GLint x,
                                                  GLint y,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLboolean unpack_flip_y,
                                                  const GLbyte* mailboxes) { … }

void GLES2Implementation::CopySharedImageToTextureINTERNAL(
    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 GLES2Implementation::BlendEquationiOES(GLuint buf, GLenum mode) { … }

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

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

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

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

void GLES2Implementation::ProvokingVertexANGLE(GLenum provokeMode) { … }

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

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

void GLES2Implementation::FramebufferPixelLocalClearValuefvANGLE(
    GLint plane,
    const GLfloat* value) { … }

void GLES2Implementation::FramebufferPixelLocalClearValueivANGLE(
    GLint plane,
    const GLint* value) { … }

void GLES2Implementation::FramebufferPixelLocalClearValueuivANGLE(
    GLint plane,
    const GLuint* value) { … }

void GLES2Implementation::BeginPixelLocalStorageANGLE(GLsizei count,
                                                      const GLenum* loadops) { … }

void GLES2Implementation::EndPixelLocalStorageANGLE(GLsizei count,
                                                    const GLenum* storeops) { … }

void GLES2Implementation::PixelLocalStorageBarrierANGLE() { … }

void GLES2Implementation::FramebufferPixelLocalStorageInterruptANGLE() { … }

void GLES2Implementation::FramebufferPixelLocalStorageRestoreANGLE() { … }

void GLES2Implementation::GetFramebufferPixelLocalStorageParameterfvANGLE(
    GLint plane,
    GLenum pname,
    GLfloat* params) { … }
void GLES2Implementation::GetFramebufferPixelLocalStorageParameterivANGLE(
    GLint plane,
    GLenum pname,
    GLint* params) { … }
void GLES2Implementation::ClipControlEXT(GLenum origin, GLenum depth) { … }

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

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

#endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_IMPL_AUTOGEN_H_