Context_gl_4_autogen.h

// GENERATED FILE - DO NOT EDIT.

// Generated by generate_entry_points.py using data from gl.xml.

//

// Copyright 2020 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.

//

// Context_gl_4_autogen.h: Creates a macro for interfaces in Context.

#ifndef ANGLE_CONTEXT_GL_4_AUTOGEN_H_

#define ANGLE_CONTEXT_GL_4_AUTOGEN_H_

#define ANGLE_GL_4_CONTEXT_API                                                                     \

    void beginQueryIndexed(GLenum target, GLuint index, QueryID idPacked);                         \

    void drawTransformFeedback(GLenum mode, TransformFeedbackID idPacked);                         \

    void drawTransformFeedbackStream(GLenum mode, TransformFeedbackID idPacked, GLuint stream);    \

    void endQueryIndexed(GLenum target, GLuint index);                                             \

    void getActiveSubroutineName(ShaderProgramID programPacked, GLenum shadertype, GLuint index,   \

                                 GLsizei bufSize, GLsizei *length, GLchar *name);                  \

    void getActiveSubroutineUniformName(ShaderProgramID programPacked, GLenum shadertype,          \

                                        GLuint index, GLsizei bufSize, GLsizei *length,            \

                                        GLchar *name);                                             \

    void getActiveSubroutineUniformiv(ShaderProgramID programPacked, GLenum shadertype,            \

                                      GLuint index, GLenum pname, GLint *values);                  \

    void getProgramStageiv(ShaderProgramID programPacked, GLenum shadertype, GLenum pname,         \

                           GLint *values);                                                         \

    void getQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params);              \

    GLuint getSubroutineIndex(ShaderProgramID programPacked, GLenum shadertype,                    \

                              const GLchar *name);                                                 \

    GLint getSubroutineUniformLocation(ShaderProgramID programPacked, GLenum shadertype,           \

                                       const GLchar *name);                                        \

    void getUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);               \

    void getUniformdv(ShaderProgramID programPacked, UniformLocation locationPacked,               \

                      GLdouble *params);                                                           \

    void patchParameterfv(GLenum pname, const GLfloat *values);                                    \

    void uniform1d(UniformLocation locationPacked, GLdouble x);                                    \

    void uniform1dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);         \

    void uniform2d(UniformLocation locationPacked, GLdouble x, GLdouble y);                        \

    void uniform2dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);         \

    void uniform3d(UniformLocation locationPacked, GLdouble x, GLdouble y, GLdouble z);            \

    void uniform3dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);         \

    void uniform4d(UniformLocation locationPacked, GLdouble x, GLdouble y, GLdouble z,             \

                   GLdouble w);                                                                    \

    void uniform4dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);         \

    void uniformMatrix2dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,      \

                          const GLdouble *value);                                                  \

    void uniformMatrix2x3dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \

                            const GLdouble *value);                                                \

    void uniformMatrix2x4dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \

                            const GLdouble *value);                                                \

    void uniformMatrix3dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,      \

                          const GLdouble *value);                                                  \

    void uniformMatrix3x2dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \

                            const GLdouble *value);                                                \

    void uniformMatrix3x4dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \

                            const GLdouble *value);                                                \

    void uniformMatrix4dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,      \

                          const GLdouble *value);                                                  \

    void uniformMatrix4x2dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \

                            const GLdouble *value);                                                \

    void uniformMatrix4x3dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \

                            const GLdouble *value);                                                \

    void uniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);           \

    void depthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);                         \

    void depthRangeIndexed(GLuint index, GLdouble n, GLdouble f);                                  \

    void getDoublei_v(GLenum target, GLuint index, GLdouble *data);                                \

    void getFloati_v(GLenum target, GLuint index, GLfloat *data);                                  \

    void getVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);                         \

    void programUniform1d(ShaderProgramID programPacked, UniformLocation locationPacked,           \

                          GLdouble v0);                                                            \

    void programUniform1dv(ShaderProgramID programPacked, UniformLocation locationPacked,          \

                           GLsizei count, const GLdouble *value);                                  \

    void programUniform2d(ShaderProgramID programPacked, UniformLocation locationPacked,           \

                          GLdouble v0, GLdouble v1);                                               \

    void programUniform2dv(ShaderProgramID programPacked, UniformLocation locationPacked,          \

                           GLsizei count, const GLdouble *value);                                  \

    void programUniform3d(ShaderProgramID programPacked, UniformLocation locationPacked,           \

                          GLdouble v0, GLdouble v1, GLdouble v2);                                  \

    void programUniform3dv(ShaderProgramID programPacked, UniformLocation locationPacked,          \

                           GLsizei count, const GLdouble *value);                                  \

    void programUniform4d(ShaderProgramID programPacked, UniformLocation locationPacked,           \

                          GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);                     \

    void programUniform4dv(ShaderProgramID programPacked, UniformLocation locationPacked,          \

                           GLsizei count, const GLdouble *value);                                  \

    void programUniformMatrix2dv(ShaderProgramID programPacked, UniformLocation locationPacked,    \

                                 GLsizei count, GLboolean transpose, const GLdouble *value);       \

    void programUniformMatrix2x3dv(ShaderProgramID programPacked, UniformLocation locationPacked,  \

                                   GLsizei count, GLboolean transpose, const GLdouble *value);     \

    void programUniformMatrix2x4dv(ShaderProgramID programPacked, UniformLocation locationPacked,  \

                                   GLsizei count, GLboolean transpose, const GLdouble *value);     \

    void programUniformMatrix3dv(ShaderProgramID programPacked, UniformLocation locationPacked,    \

                                 GLsizei count, GLboolean transpose, const GLdouble *value);       \

    void programUniformMatrix3x2dv(ShaderProgramID programPacked, UniformLocation locationPacked,  \

                                   GLsizei count, GLboolean transpose, const GLdouble *value);     \

    void programUniformMatrix3x4dv(ShaderProgramID programPacked, UniformLocation locationPacked,  \

                                   GLsizei count, GLboolean transpose, const GLdouble *value);     \

    void programUniformMatrix4dv(ShaderProgramID programPacked, UniformLocation locationPacked,    \

                                 GLsizei count, GLboolean transpose, const GLdouble *value);       \

    void programUniformMatrix4x2dv(ShaderProgramID programPacked, UniformLocation locationPacked,  \

                                   GLsizei count, GLboolean transpose, const GLdouble *value);     \

    void programUniformMatrix4x3dv(ShaderProgramID programPacked, UniformLocation locationPacked,  \

                                   GLsizei count, GLboolean transpose, const GLdouble *value);     \

    void scissorArrayv(GLuint first, GLsizei count, const GLint *v);                               \

    void scissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);    \

    void scissorIndexedv(GLuint index, const GLint *v);                                            \

    void vertexAttribL1d(GLuint index, GLdouble x);                                                \

    void vertexAttribL1dv(GLuint index, const GLdouble *v);                                        \

    void vertexAttribL2d(GLuint index, GLdouble x, GLdouble y);                                    \

    void vertexAttribL2dv(GLuint index, const GLdouble *v);                                        \

    void vertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);                        \

    void vertexAttribL3dv(GLuint index, const GLdouble *v);                                        \

    void vertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);            \

    void vertexAttribL4dv(GLuint index, const GLdouble *v);                                        \

    void vertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride,               \

                              const void *pointer);                                                \

    void viewportArrayv(GLuint first, GLsizei count, const GLfloat *v);                            \

    void viewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);               \

    void viewportIndexedfv(GLuint index, const GLfloat *v);                                        \

    void drawTransformFeedbackInstanced(GLenum mode, TransformFeedbackID idPacked,                 \

                                        GLsizei instancecount);                                    \

    void drawTransformFeedbackStreamInstanced(GLenum mode, TransformFeedbackID idPacked,           \

                                              GLuint stream, GLsizei instancecount);               \

    void getActiveAtomicCounterBufferiv(ShaderProgramID programPacked, GLuint bufferIndex,         \

                                        GLenum pname, GLint *params);                              \

    void clearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type,         \

                         const void *data);                                                        \

    void clearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset,                 \

                            GLsizeiptr size, GLenum format, GLenum type, const void *data);        \

    void getInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei count,  \

                               GLint64 *params);                                                   \

    void invalidateBufferData(BufferID bufferPacked);                                              \

    void invalidateBufferSubData(BufferID bufferPacked, GLintptr offset, GLsizeiptr length);       \

    void invalidateTexImage(TextureID texturePacked, GLint level);                                 \

    void invalidateTexSubImage(TextureID texturePacked, GLint level, GLint xoffset, GLint yoffset, \

                               GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);       \

    void shaderStorageBlockBinding(ShaderProgramID programPacked, GLuint storageBlockIndex,        \

                                   GLuint storageBlockBinding);                                    \

    void textureView(TextureID texturePacked, GLenum target, GLuint origtexture,                   \

                     GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer,    \

                     GLuint numlayers);                                                            \

    void vertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);  \

    void bindBuffersBase(GLenum target, GLuint first, GLsizei count,                               \

                         const BufferID *buffersPacked);                                           \

    void bindBuffersRange(GLenum target, GLuint first, GLsizei count,                              \

                          const BufferID *buffersPacked, const GLintptr *offsets,                  \

                          const GLsizeiptr *sizes);                                                \

    void bindImageTextures(GLuint first, GLsizei count, const GLuint *textures);                   \

    void bindSamplers(GLuint first, GLsizei count, const GLuint *samplers);                        \

    void bindTextures(GLuint first, GLsizei count, const GLuint *textures);                        \

    void bindVertexBuffers(GLuint first, GLsizei count, const BufferID *buffersPacked,             \

                           const GLintptr *offsets, const GLsizei *strides);                       \

    void clearTexImage(TextureID texturePacked, GLint level, GLenum format, GLenum type,           \

                       const void *data);                                                          \

    void clearTexSubImage(TextureID texturePacked, GLint level, GLint xoffset, GLint yoffset,      \

                          GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,             \

                          GLenum format, GLenum type, const void *data);                           \

    void bindTextureUnit(GLuint unit, TextureID texturePacked);                                    \

    void blitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0,         \

                              GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0,     \

                              GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);           \

    GLenum checkNamedFramebufferStatus(FramebufferID framebufferPacked, GLenum target);            \

    void clearNamedBufferData(BufferID bufferPacked, GLenum internalformat, GLenum format,         \

                              GLenum type, const void *data);                                      \

    void clearNamedBufferSubData(BufferID bufferPacked, GLenum internalformat, GLintptr offset,    \

                                 GLsizeiptr size, GLenum format, GLenum type, const void *data);   \

    void clearNamedFramebufferfi(FramebufferID framebufferPacked, GLenum buffer, GLint drawbuffer, \

                                 GLfloat depth, GLint stencil);                                    \

    void clearNamedFramebufferfv(FramebufferID framebufferPacked, GLenum buffer, GLint drawbuffer, \

                                 const GLfloat *value);                                            \

    void clearNamedFramebufferiv(FramebufferID framebufferPacked, GLenum buffer, GLint drawbuffer, \

                                 const GLint *value);                                              \

    void clearNamedFramebufferuiv(FramebufferID framebufferPacked, GLenum buffer,                  \

                                  GLint drawbuffer, const GLuint *value);                          \

    void compressedTextureSubImage1D(TextureID texturePacked, GLint level, GLint xoffset,          \

                                     GLsizei width, GLenum format, GLsizei imageSize,              \

                                     const void *data);                                            \

    void compressedTextureSubImage2D(TextureID texturePacked, GLint level, GLint xoffset,          \

                                     GLint yoffset, GLsizei width, GLsizei height, GLenum format,  \

                                     GLsizei imageSize, const void *data);                         \

    void compressedTextureSubImage3D(TextureID texturePacked, GLint level, GLint xoffset,          \

                                     GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,  \

                                     GLsizei depth, GLenum format, GLsizei imageSize,              \

                                     const void *data);                                            \

    void copyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset,        \

                                GLintptr writeOffset, GLsizeiptr size);                            \

    void copyTextureSubImage1D(TextureID texturePacked, GLint level, GLint xoffset, GLint x,       \

                               GLint y, GLsizei width);                                            \

    void copyTextureSubImage2D(TextureID texturePacked, GLint level, GLint xoffset, GLint yoffset, \

                               GLint x, GLint y, GLsizei width, GLsizei height);                   \

    void copyTextureSubImage3D(TextureID texturePacked, GLint level, GLint xoffset, GLint yoffset, \

                               GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);    \

    void createBuffers(GLsizei n, BufferID *buffersPacked);                                        \

    void createFramebuffers(GLsizei n, GLuint *framebuffers);                                      \

    void createProgramPipelines(GLsizei n, GLuint *pipelines);                                     \

    void createQueries(GLenum target, GLsizei n, GLuint *ids);                                     \

    void createRenderbuffers(GLsizei n, RenderbufferID *renderbuffersPacked);                      \

    void createSamplers(GLsizei n, GLuint *samplers);                                              \

    void createTextures(GLenum target, GLsizei n, GLuint *textures);                               \

    void createTransformFeedbacks(GLsizei n, GLuint *ids);                                         \

    void createVertexArrays(GLsizei n, VertexArrayID *arraysPacked);                               \

    void disableVertexArrayAttrib(VertexArrayID vaobjPacked, GLuint index);                        \

    void enableVertexArrayAttrib(VertexArrayID vaobjPacked, GLuint index);                         \

    void flushMappedNamedBufferRange(BufferID bufferPacked, GLintptr offset, GLsizeiptr length);   \

    void generateTextureMipmap(TextureID texturePacked);                                           \

    void getCompressedTextureImage(TextureID texturePacked, GLint level, GLsizei bufSize,          \

                                   void *pixels);                                                  \

    void getCompressedTextureSubImage(TextureID texturePacked, GLint level, GLint xoffset,         \

                                      GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, \

                                      GLsizei depth, GLsizei bufSize, void *pixels);               \

    void getNamedBufferParameteri64v(BufferID bufferPacked, GLenum pname, GLint64 *params);        \

    void getNamedBufferParameteriv(BufferID bufferPacked, GLenum pname, GLint *params);            \

    void getNamedBufferPointerv(BufferID bufferPacked, GLenum pname, void **params);               \

    void getNamedBufferSubData(BufferID bufferPacked, GLintptr offset, GLsizeiptr size,            \

                               void *data);                                                        \

    void getNamedFramebufferAttachmentParameteriv(FramebufferID framebufferPacked,                 \

                                                  GLenum attachment, GLenum pname, GLint *params); \

    void getNamedFramebufferParameteriv(FramebufferID framebufferPacked, GLenum pname,             \

                                        GLint *param);                                             \

    void getNamedRenderbufferParameteriv(RenderbufferID renderbufferPacked, GLenum pname,          \

                                         GLint *params);                                           \

    void getQueryBufferObjecti64v(GLuint id, BufferID bufferPacked, GLenum pname,                  \

                                  GLintptr offset);                                                \

    void getQueryBufferObjectiv(GLuint id, BufferID bufferPacked, GLenum pname, GLintptr offset);  \

    void getQueryBufferObjectui64v(GLuint id, BufferID bufferPacked, GLenum pname,                 \

                                   GLintptr offset);                                               \

    void getQueryBufferObjectuiv(GLuint id, BufferID bufferPacked, GLenum pname, GLintptr offset); \

    void getTextureImage(TextureID texturePacked, GLint level, GLenum format, GLenum type,         \

                         GLsizei bufSize, void *pixels);                                           \

    void getTextureLevelParameterfv(TextureID texturePacked, GLint level, GLenum pname,            \

                                    GLfloat *params);                                              \

    void getTextureLevelParameteriv(TextureID texturePacked, GLint level, GLenum pname,            \

                                    GLint *params);                                                \

    void getTextureParameterIiv(TextureID texturePacked, GLenum pname, GLint *params);             \

    void getTextureParameterIuiv(TextureID texturePacked, GLenum pname, GLuint *params);           \

    void getTextureParameterfv(TextureID texturePacked, GLenum pname, GLfloat *params);            \

    void getTextureParameteriv(TextureID texturePacked, GLenum pname, GLint *params);              \

    void getTextureSubImage(TextureID texturePacked, GLint level, GLint xoffset, GLint yoffset,    \

                            GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,           \

                            GLenum format, GLenum type, GLsizei bufSize, void *pixels);            \

    void getTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param);        \

    void getTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param);            \

    void getTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param);                           \

    void getVertexArrayIndexed64iv(VertexArrayID vaobjPacked, GLuint index, GLenum pname,          \

                                   GLint64 *param);                                                \

    void getVertexArrayIndexediv(VertexArrayID vaobjPacked, GLuint index, GLenum pname,            \

                                 GLint *param);                                                    \

    void getVertexArrayiv(VertexArrayID vaobjPacked, GLenum pname, GLint *param);                  \

    void getnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table);  \

    void getnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels);          \

    void getnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize,         \

                               void *image);                                                       \

    void getnHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type,                 \

                       GLsizei bufSize, void *values);                                             \

    void getnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);                     \

    void getnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);                      \

    void getnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v);                        \

    void getnMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize,   \

                    void *values);                                                                 \

    void getnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values);                             \

    void getnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values);                             \

    void getnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values);                           \

    void getnPolygonStipple(GLsizei bufSize, GLubyte *pattern);                                    \

    void getnSeparableFilter(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize,        \

                             void *row, GLsizei columnBufSize, void *column, void *span);          \

    void getnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize,     \

                      void *pixels);                                                               \

    void getnUniformdv(ShaderProgramID programPacked, UniformLocation locationPacked,              \

                       GLsizei bufSize, GLdouble *params);                                         \

    void invalidateNamedFramebufferData(FramebufferID framebufferPacked, GLsizei numAttachments,   \

                                        const GLenum *attachments);                                \

    void invalidateNamedFramebufferSubData(FramebufferID framebufferPacked,                        \

                                           GLsizei numAttachments, const GLenum *attachments,      \

                                           GLint x, GLint y, GLsizei width, GLsizei height);       \

    void *mapNamedBuffer(BufferID bufferPacked, GLenum access);                                    \

    void *mapNamedBufferRange(BufferID bufferPacked, GLintptr offset, GLsizeiptr length,           \

                              GLbitfield access);                                                  \

    void namedBufferData(BufferID bufferPacked, GLsizeiptr size, const void *data, GLenum usage);  \

    void namedBufferStorage(BufferID bufferPacked, GLsizeiptr size, const void *data,              \

                            GLbitfield flags);                                                     \

    void namedBufferSubData(BufferID bufferPacked, GLintptr offset, GLsizeiptr size,               \

                            const void *data);                                                     \

    void namedFramebufferDrawBuffer(FramebufferID framebufferPacked, GLenum buf);                  \

    void namedFramebufferDrawBuffers(FramebufferID framebufferPacked, GLsizei n,                   \

                                     const GLenum *bufs);                                          \

    void namedFramebufferParameteri(FramebufferID framebufferPacked, GLenum pname, GLint param);   \

    void namedFramebufferReadBuffer(FramebufferID framebufferPacked, GLenum src);                  \

    void namedFramebufferRenderbuffer(FramebufferID framebufferPacked, GLenum attachment,          \

                                      GLenum renderbuffertarget,                                   \

                                      RenderbufferID renderbufferPacked);                          \

    void namedFramebufferTexture(FramebufferID framebufferPacked, GLenum attachment,               \

                                 TextureID texturePacked, GLint level);                            \

    void namedFramebufferTextureLayer(FramebufferID framebufferPacked, GLenum attachment,          \

                                      TextureID texturePacked, GLint level, GLint layer);          \

    void namedRenderbufferStorage(RenderbufferID renderbufferPacked, GLenum internalformat,        \

                                  GLsizei width, GLsizei height);                                  \

    void namedRenderbufferStorageMultisample(RenderbufferID renderbufferPacked, GLsizei samples,   \

                                             GLenum internalformat, GLsizei width,                 \

                                             GLsizei height);                                      \

    void textureBarrier();                                                                         \

    void textureBuffer(TextureID texturePacked, GLenum internalformat, BufferID bufferPacked);     \

    void textureBufferRange(TextureID texturePacked, GLenum internalformat, BufferID bufferPacked, \

                            GLintptr offset, GLsizeiptr size);                                     \

    void textureParameterIiv(TextureID texturePacked, GLenum pname, const GLint *params);          \

    void textureParameterIuiv(TextureID texturePacked, GLenum pname, const GLuint *params);        \

    void textureParameterf(TextureID texturePacked, GLenum pname, GLfloat param);                  \

    void textureParameterfv(TextureID texturePacked, GLenum pname, const GLfloat *param);          \

    void textureParameteri(TextureID texturePacked, GLenum pname, GLint param);                    \

    void textureParameteriv(TextureID texturePacked, GLenum pname, const GLint *param);            \

    void textureStorage1D(TextureID texturePacked, GLsizei levels, GLenum internalformat,          \

                          GLsizei width);                                                          \

    void textureStorage2D(TextureID texturePacked, GLsizei levels, GLenum internalformat,          \

                          GLsizei width, GLsizei height);                                          \

    void textureStorage2DMultisample(TextureID texturePacked, GLsizei samples,                     \

                                     GLenum internalformat, GLsizei width, GLsizei height,         \

                                     GLboolean fixedsamplelocations);                              \

    void textureStorage3D(TextureID texturePacked, GLsizei levels, GLenum internalformat,          \

                          GLsizei width, GLsizei height, GLsizei depth);                           \

    void textureStorage3DMultisample(TextureID texturePacked, GLsizei samples,                     \

                                     GLenum internalformat, GLsizei width, GLsizei height,         \

                                     GLsizei depth, GLboolean fixedsamplelocations);               \

    void textureSubImage1D(TextureID texturePacked, GLint level, GLint xoffset, GLsizei width,     \

                           GLenum format, GLenum type, const void *pixels);                        \

    void textureSubImage2D(TextureID texturePacked, GLint level, GLint xoffset, GLint yoffset,     \

                           GLsizei width, GLsizei height, GLenum format, GLenum type,              \

                           const void *pixels);                                                    \

    void textureSubImage3D(TextureID texturePacked, GLint level, GLint xoffset, GLint yoffset,     \

                           GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,            \

                           GLenum format, GLenum type, const void *pixels);                        \

    void transformFeedbackBufferBase(GLuint xfb, GLuint index, BufferID bufferPacked);             \

    void transformFeedbackBufferRange(GLuint xfb, GLuint index, BufferID bufferPacked,             \

                                      GLintptr offset, GLsizeiptr size);                           \

    GLboolean unmapNamedBuffer(BufferID bufferPacked);                                             \

    void vertexArrayAttribBinding(VertexArrayID vaobjPacked, GLuint attribindex,                   \

                                  GLuint bindingindex);                                            \

    void vertexArrayAttribFormat(VertexArrayID vaobjPacked, GLuint attribindex, GLint size,        \

                                 GLenum type, GLboolean normalized, GLuint relativeoffset);        \

    void vertexArrayAttribIFormat(VertexArrayID vaobjPacked, GLuint attribindex, GLint size,       \

                                  GLenum type, GLuint relativeoffset);                             \

    void vertexArrayAttribLFormat(VertexArrayID vaobjPacked, GLuint attribindex, GLint size,       \

                                  GLenum type, GLuint relativeoffset);                             \

    void vertexArrayBindingDivisor(VertexArrayID vaobjPacked, GLuint bindingindex,                 \

                                   GLuint divisor);                                                \

    void vertexArrayElementBuffer(VertexArrayID vaobjPacked, BufferID bufferPacked);               \

    void vertexArrayVertexBuffer(VertexArrayID vaobjPacked, GLuint bindingindex,                   \

                                 BufferID bufferPacked, GLintptr offset, GLsizei stride);          \

    void vertexArrayVertexBuffers(VertexArrayID vaobjPacked, GLuint first, GLsizei count,          \

                                  const BufferID *buffersPacked, const GLintptr *offsets,          \

                                  const GLsizei *strides);                                         \

    void multiDrawArraysIndirectCount(GLenum mode, const void *indirect, GLintptr drawcount,       \

                                      GLsizei maxdrawcount, GLsizei stride);                       \

    void multiDrawElementsIndirectCount(GLenum mode, GLenum type, const void *indirect,            \

                                        GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); \

    void polygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat clamp);                         \

    void specializeShader(GLuint shader, const GLchar *pEntryPoint,                                \

                          GLuint numSpecializationConstants, const GLuint *pConstantIndex,         \

                          const GLuint *pConstantValue);

#endif  // ANGLE_CONTEXT_API_4_AUTOGEN_H_

Source code

Revision control

Copy as Markdown

Other Tools