kc3-lang/angle/src/libANGLE/Context.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Yunchao He
  Date : 2017-08-04 13:42:39
  Hash : a438f4e7
  Message : Fix some style issues BUG=angleproject:2123 Change-Id: Ic3c70c7148297662d4fd9e08edcd208f5a1cc885 Reviewed-on: https://chromium-review.googlesource.com/601370 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org>

• src/libANGLE/Context.h

• //
  // Copyright (c) 2002-2014 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.h: Defines the gl::Context class, managing all GL state and performing
  // rendering operations. It is the GLES2 specific implementation of EGLContext.
  
  #ifndef LIBANGLE_CONTEXT_H_
  #define LIBANGLE_CONTEXT_H_
  
  #include <set>
  #include <string>
  
  #include "angle_gl.h"
  #include "common/MemoryBuffer.h"
  #include "common/angleutils.h"
  #include "libANGLE/Caps.h"
  #include "libANGLE/Constants.h"
  #include "libANGLE/ContextState.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/HandleAllocator.h"
  #include "libANGLE/RefCountObject.h"
  #include "libANGLE/ResourceMap.h"
  #include "libANGLE/VertexAttribute.h"
  #include "libANGLE/Workarounds.h"
  #include "libANGLE/angletypes.h"
  
  namespace rx
  {
  class ContextImpl;
  class EGLImplFactory;
  }
  
  namespace egl
  {
  class AttributeMap;
  class Surface;
  struct Config;
  class Thread;
  }
  
  namespace gl
  {
  class Buffer;
  class Compiler;
  class FenceNV;
  class FenceSync;
  class Framebuffer;
  class MemoryProgramCache;
  class Program;
  class Query;
  class Renderbuffer;
  class Sampler;
  class Shader;
  class Texture;
  class TransformFeedback;
  class VertexArray;
  struct VertexAttribute;
  
  class Context final : public ValidationContext
  {
    public:
      Context(rx::EGLImplFactory *implFactory,
              const egl::Config *config,
              const Context *shareContext,
              TextureManager *shareTextures,
              MemoryProgramCache *memoryProgramCache,
              const egl::AttributeMap &attribs,
              const egl::DisplayExtensions &displayExtensions,
              bool robustResourceInit);
  
      egl::Error onDestroy(const egl::Display *display);
      ~Context() override;
  
      egl::Error makeCurrent(egl::Display *display, egl::Surface *surface);
      egl::Error releaseSurface(const egl::Display *display);
  
      // These create  and destroy methods are merely pass-throughs to
      // ResourceManager, which owns these object types
      GLuint createBuffer();
      GLuint createShader(GLenum type);
      GLuint createProgram();
      GLuint createTexture();
      GLuint createRenderbuffer();
      GLuint createSampler();
      GLuint createTransformFeedback();
      GLsync createFenceSync();
      GLuint createPaths(GLsizei range);
  
      void deleteBuffer(GLuint buffer);
      void deleteShader(GLuint shader);
      void deleteProgram(GLuint program);
      void deleteTexture(GLuint texture);
      void deleteRenderbuffer(GLuint renderbuffer);
      void deleteSampler(GLuint sampler);
      void deleteTransformFeedback(GLuint transformFeedback);
      void deleteFenceSync(GLsync fenceSync);
      void deletePaths(GLuint first, GLsizei range);
  
      // CHROMIUM_path_rendering
      bool hasPathData(GLuint path) const;
      bool hasPath(GLuint path) const;
      void setPathCommands(GLuint path,
                           GLsizei numCommands,
                           const GLubyte *commands,
                           GLsizei numCoords,
                           GLenum coordType,
                           const void *coords);
      void setPathParameterf(GLuint path, GLenum pname, GLfloat value);
      void getPathParameterfv(GLuint path, GLenum pname, GLfloat *value) const;
      void setPathStencilFunc(GLenum func, GLint ref, GLuint mask);
  
      // Framebuffers are owned by the Context, so these methods do not pass through
      GLuint createFramebuffer();
      void deleteFramebuffer(GLuint framebuffer);
  
      // NV Fences are owned by the Context.
      GLuint createFenceNV();
      void deleteFenceNV(GLuint fence);
  
      // Queries are owned by the Context;
      GLuint createQuery();
      void deleteQuery(GLuint query);
  
      // Vertex arrays are owned by the Context
      GLuint createVertexArray();
      void deleteVertexArray(GLuint vertexArray);
  
      void bindArrayBuffer(GLuint bufferHandle);
      void bindElementArrayBuffer(GLuint bufferHandle);
      void bindTexture(GLenum target, GLuint handle);
      void bindReadFramebuffer(GLuint framebufferHandle);
      void bindDrawFramebuffer(GLuint framebufferHandle);
      void bindVertexArray(GLuint vertexArrayHandle);
      void bindVertexBuffer(GLuint bindingIndex,
                            GLuint bufferHandle,
                            GLintptr offset,
                            GLsizei stride);
      void bindSampler(GLuint textureUnit, GLuint samplerHandle);
      void bindImageTexture(GLuint unit,
                            GLuint texture,
                            GLint level,
                            GLboolean layered,
                            GLint layer,
                            GLenum access,
                            GLenum format);
      void bindGenericUniformBuffer(GLuint bufferHandle);
      void bindIndexedUniformBuffer(GLuint bufferHandle,
                                    GLuint index,
                                    GLintptr offset,
                                    GLsizeiptr size);
      void bindGenericTransformFeedbackBuffer(GLuint bufferHandle);
      void bindIndexedTransformFeedbackBuffer(GLuint bufferHandle,
                                              GLuint index,
                                              GLintptr offset,
                                              GLsizeiptr size);
      void bindGenericAtomicCounterBuffer(GLuint bufferHandle);
      void bindIndexedAtomicCounterBuffer(GLuint bufferHandle,
                                          GLuint index,
                                          GLintptr offset,
                                          GLsizeiptr size);
      void bindGenericShaderStorageBuffer(GLuint bufferHandle);
      void bindIndexedShaderStorageBuffer(GLuint bufferHandle,
                                          GLuint index,
                                          GLintptr offset,
                                          GLsizeiptr size);
      void bindCopyReadBuffer(GLuint bufferHandle);
      void bindCopyWriteBuffer(GLuint bufferHandle);
      void bindPixelPackBuffer(GLuint bufferHandle);
      void bindPixelUnpackBuffer(GLuint bufferHandle);
      void useProgram(GLuint program);
      void bindTransformFeedback(GLuint transformFeedbackHandle);
      void bindDrawIndirectBuffer(GLuint bufferHandle);
  
      Error beginQuery(GLenum target, GLuint query);
      Error endQuery(GLenum target);
      Error queryCounter(GLuint id, GLenum target);
      void getQueryiv(GLenum target, GLenum pname, GLint *params);
      void getQueryObjectiv(GLuint id, GLenum pname, GLint *params);
      void getQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
      void getQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params);
      void getQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params);
  
      void setVertexAttribDivisor(GLuint index, GLuint divisor);
      void setVertexBindingDivisor(GLuint bindingIndex, GLuint divisor);
  
      void getBufferParameteriv(GLenum target, GLenum pname, GLint *params);
      void getFramebufferAttachmentParameteriv(GLenum target,
                                               GLenum attachment,
                                               GLenum pname,
                                               GLint *params);
      void getRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
  
      void getTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
      void getTexParameteriv(GLenum target, GLenum pname, GLint *params);
      void texParameterf(GLenum target, GLenum pname, GLfloat param);
      void texParameterfv(GLenum target, GLenum pname, const GLfloat *params);
      void texParameteri(GLenum target, GLenum pname, GLint param);
      void texParameteriv(GLenum target, GLenum pname, const GLint *params);
  
      void samplerParameteri(GLuint sampler, GLenum pname, GLint param);
      void samplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
      void samplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
      void samplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param);
  
      void getSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
      void getSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
  
      void programParameteri(GLuint program, GLenum pname, GLint value);
  
      GLuint getProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
      void getProgramResourceName(GLuint program,
                                  GLenum programInterface,
                                  GLuint index,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLchar *name);
      GLint getProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
      void getProgramResourceiv(GLuint program,
                                GLenum programInterface,
                                GLuint index,
                                GLsizei propCount,
                                const GLenum *props,
                                GLsizei bufSize,
                                GLsizei *length,
                                GLint *params);
  
      Buffer *getBuffer(GLuint handle) const;
      FenceNV *getFenceNV(GLuint handle);
      FenceSync *getFenceSync(GLsync handle) const;
      Texture *getTexture(GLuint handle) const;
      Framebuffer *getFramebuffer(GLuint handle) const;
      Renderbuffer *getRenderbuffer(GLuint handle) const;
      VertexArray *getVertexArray(GLuint handle) const;
      Sampler *getSampler(GLuint handle) const;
      Query *getQuery(GLuint handle, bool create, GLenum type);
      Query *getQuery(GLuint handle) const;
      TransformFeedback *getTransformFeedback(GLuint handle) const;
      void objectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
      void objectPtrLabel(const void *ptr, GLsizei length, const GLchar *label);
      void getObjectLabel(GLenum identifier,
                          GLuint name,
                          GLsizei bufSize,
                          GLsizei *length,
                          GLchar *label) const;
      void getObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label) const;
  
      Texture *getTargetTexture(GLenum target) const;
      Texture *getSamplerTexture(unsigned int sampler, GLenum type) const;
  
      Compiler *getCompiler() const;
  
      bool isSampler(GLuint samplerName) const;
  
      bool isVertexArrayGenerated(GLuint vertexArray);
      bool isTransformFeedbackGenerated(GLuint vertexArray);
  
      void getBooleanv(GLenum pname, GLboolean *params);
      void getBooleanvImpl(GLenum pname, GLboolean *params);
      void getFloatv(GLenum pname, GLfloat *params);
      void getFloatvImpl(GLenum pname, GLfloat *params);
      void getIntegerv(GLenum pname, GLint *params);
      void getIntegervImpl(GLenum pname, GLint *params);
      void getInteger64v(GLenum pname, GLint64 *params);
      void getPointerv(GLenum pname, void **params) const;
      void getBooleani_v(GLenum target, GLuint index, GLboolean *data);
      void getIntegeri_v(GLenum target, GLuint index, GLint *data);
      void getInteger64i_v(GLenum target, GLuint index, GLint64 *data);
  
      void activeTexture(GLenum texture);
      void blendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat 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 clearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
      void clearDepthf(GLfloat depth);
      void clearStencil(GLint s);
      void colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
      void cullFace(GLenum mode);
      void depthFunc(GLenum func);
      void depthMask(GLboolean flag);
      void depthRangef(GLfloat zNear, GLfloat zFar);
      void disable(GLenum cap);
      void disableVertexAttribArray(GLuint index);
      void enable(GLenum cap);
      void enableVertexAttribArray(GLuint index);
      void frontFace(GLenum mode);
      void hint(GLenum target, GLenum mode);
      void lineWidth(GLfloat width);
      void pixelStorei(GLenum pname, GLint param);
      void polygonOffset(GLfloat factor, GLfloat units);
      void sampleCoverage(GLfloat value, GLboolean invert);
      void scissor(GLint x, GLint y, GLsizei width, GLsizei height);
      void stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
      void stencilMaskSeparate(GLenum face, GLuint mask);
      void stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
      void vertexAttrib1f(GLuint index, GLfloat x);
      void vertexAttrib1fv(GLuint index, const GLfloat *values);
      void vertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
      void vertexAttrib2fv(GLuint index, const GLfloat *values);
      void vertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
      void vertexAttrib3fv(GLuint index, const GLfloat *values);
      void vertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
      void vertexAttrib4fv(GLuint index, const GLfloat *values);
      void vertexAttribFormat(GLuint attribIndex,
                              GLint size,
                              GLenum type,
                              GLboolean normalized,
                              GLuint relativeOffset);
      void vertexAttribIFormat(GLuint attribIndex, GLint size, GLenum type, GLuint relativeOffset);
      void vertexAttribBinding(GLuint attribIndex, GLuint bindingIndex);
      void vertexAttribPointer(GLuint index,
                               GLint size,
                               GLenum type,
                               GLboolean normalized,
                               GLsizei stride,
                               const void *ptr);
      void vertexAttribIPointer(GLuint index,
                                GLint size,
                                GLenum type,
                                GLsizei stride,
                                const void *pointer);
      void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
  
      void vertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
      void vertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
      void vertexAttribI4iv(GLuint index, const GLint *v);
      void vertexAttribI4uiv(GLuint index, const GLuint *v);
      void getVertexAttribiv(GLuint index, GLenum pname, GLint *params);
      void getVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
      void getVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
      void getVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
      void getVertexAttribPointerv(GLuint index, GLenum pname, void **pointer);
  
      void debugMessageControl(GLenum source,
                               GLenum type,
                               GLenum severity,
                               GLsizei count,
                               const GLuint *ids,
                               GLboolean enabled);
      void debugMessageInsert(GLenum source,
                              GLenum type,
                              GLuint id,
                              GLenum severity,
                              GLsizei length,
                              const GLchar *buf);
      void debugMessageCallback(GLDEBUGPROCKHR callback, const void *userParam);
      GLuint getDebugMessageLog(GLuint count,
                                GLsizei bufSize,
                                GLenum *sources,
                                GLenum *types,
                                GLuint *ids,
                                GLenum *severities,
                                GLsizei *lengths,
                                GLchar *messageLog);
      void pushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message);
      void popDebugGroup();
  
      void clear(GLbitfield mask);
      void clearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *values);
      void clearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *values);
      void clearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *values);
      void clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
  
      void drawArrays(GLenum mode, GLint first, GLsizei count);
      void drawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
  
      void drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
      void drawElementsInstanced(GLenum mode,
                                 GLsizei count,
                                 GLenum type,
                                 const void *indices,
                                 GLsizei instances);
      void drawRangeElements(GLenum mode,
                             GLuint start,
                             GLuint end,
                             GLsizei count,
                             GLenum type,
                             const void *indices);
      void drawArraysIndirect(GLenum mode, const void *indirect);
      void drawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
  
      void blitFramebuffer(GLint srcX0,
                           GLint srcY0,
                           GLint srcX1,
                           GLint srcY1,
                           GLint dstX0,
                           GLint dstY0,
                           GLint dstX1,
                           GLint dstY1,
                           GLbitfield mask,
                           GLenum filter);
  
      void readPixels(GLint x,
                      GLint y,
                      GLsizei width,
                      GLsizei height,
                      GLenum format,
                      GLenum type,
                      void *pixels);
  
      void copyTexImage2D(GLenum target,
                          GLint level,
                          GLenum internalformat,
                          GLint x,
                          GLint y,
                          GLsizei width,
                          GLsizei height,
                          GLint border);
  
      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 framebufferTexture2D(GLenum target,
                                GLenum attachment,
                                GLenum textarget,
                                GLuint texture,
                                GLint level);
  
      void framebufferRenderbuffer(GLenum target,
                                   GLenum attachment,
                                   GLenum renderbuffertarget,
                                   GLuint renderbuffer);
  
      void framebufferTextureLayer(GLenum target,
                                   GLenum attachment,
                                   GLuint texture,
                                   GLint level,
                                   GLint layer);
      void framebufferTextureMultiviewLayeredANGLE(GLenum target,
                                                   GLenum attachment,
                                                   GLuint texture,
                                                   GLint level,
                                                   GLint baseViewIndex,
                                                   GLsizei numViews);
      void framebufferTextureMultiviewSideBySideANGLE(GLenum target,
                                                      GLenum attachment,
                                                      GLuint texture,
                                                      GLint level,
                                                      GLsizei numViews,
                                                      const GLint *viewportOffsets);
  
      void drawBuffers(GLsizei n, const GLenum *bufs);
      void readBuffer(GLenum mode);
  
      void discardFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
      void invalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
      void invalidateSubFramebuffer(GLenum target,
                                    GLsizei numAttachments,
                                    const GLenum *attachments,
                                    GLint x,
                                    GLint y,
                                    GLsizei width,
                                    GLsizei height);
  
      void texImage2D(GLenum target,
                      GLint level,
                      GLint internalformat,
                      GLsizei width,
                      GLsizei height,
                      GLint border,
                      GLenum format,
                      GLenum type,
                      const void *pixels);
      void texImage3D(GLenum target,
                      GLint level,
                      GLint internalformat,
                      GLsizei width,
                      GLsizei height,
                      GLsizei depth,
                      GLint border,
                      GLenum format,
                      GLenum type,
                      const void *pixels);
      void texSubImage2D(GLenum target,
                         GLint level,
                         GLint xoffset,
                         GLint yoffset,
                         GLsizei width,
                         GLsizei height,
                         GLenum format,
                         GLenum type,
                         const void *pixels);
      void texSubImage3D(GLenum target,
                         GLint level,
                         GLint xoffset,
                         GLint yoffset,
                         GLint zoffset,
                         GLsizei width,
                         GLsizei height,
                         GLsizei depth,
                         GLenum format,
                         GLenum type,
                         const void *pixels);
      void compressedTexImage2D(GLenum target,
                                GLint level,
                                GLenum internalformat,
                                GLsizei width,
                                GLsizei height,
                                GLint border,
                                GLsizei imageSize,
                                const void *data);
      void compressedTexImage3D(GLenum target,
                                GLint level,
                                GLenum internalformat,
                                GLsizei width,
                                GLsizei height,
                                GLsizei depth,
                                GLint border,
                                GLsizei imageSize,
                                const void *data);
      void compressedTexSubImage2D(GLenum target,
                                   GLint level,
                                   GLint xoffset,
                                   GLint yoffset,
                                   GLsizei width,
                                   GLsizei height,
                                   GLenum format,
                                   GLsizei imageSize,
                                   const void *data);
      void compressedTexSubImage3D(GLenum target,
                                   GLint level,
                                   GLint xoffset,
                                   GLint yoffset,
                                   GLint zoffset,
                                   GLsizei width,
                                   GLsizei height,
                                   GLsizei depth,
                                   GLenum format,
                                   GLsizei imageSize,
                                   const void *data);
      void copyTextureCHROMIUM(GLuint sourceId,
                               GLint sourceLevel,
                               GLenum destTarget,
                               GLuint destId,
                               GLint destLevel,
                               GLint internalFormat,
                               GLenum destType,
                               GLboolean unpackFlipY,
                               GLboolean unpackPremultiplyAlpha,
                               GLboolean unpackUnmultiplyAlpha);
      void copySubTextureCHROMIUM(GLuint sourceId,
                                  GLint sourceLevel,
                                  GLenum destTarget,
                                  GLuint destId,
                                  GLint destLevel,
                                  GLint xoffset,
                                  GLint yoffset,
                                  GLint x,
                                  GLint y,
                                  GLsizei width,
                                  GLsizei height,
                                  GLboolean unpackFlipY,
                                  GLboolean unpackPremultiplyAlpha,
                                  GLboolean unpackUnmultiplyAlpha);
      void compressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId);
  
      void generateMipmap(GLenum target);
  
      void flush();
      void finish();
  
      void getBufferPointerv(GLenum target, GLenum pname, void **params);
      void *mapBuffer(GLenum target, GLenum access);
      GLboolean unmapBuffer(GLenum target);
      void *mapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
      void flushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
  
      void beginTransformFeedback(GLenum primitiveMode);
  
      bool hasActiveTransformFeedback(GLuint program) const;
  
      void insertEventMarker(GLsizei length, const char *marker);
      void pushGroupMarker(GLsizei length, const char *marker);
      void popGroupMarker();
  
      void bindUniformLocation(GLuint program, GLint location, const GLchar *name);
      void renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
      void renderbufferStorageMultisample(GLenum target,
                                          GLsizei samples,
                                          GLenum internalformat,
                                          GLsizei width,
                                          GLsizei height);
  
      void getSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
  
      // CHROMIUM_framebuffer_mixed_samples
      void setCoverageModulation(GLenum components);
  
      // CHROMIUM_path_rendering
      void loadPathRenderingMatrix(GLenum matrixMode, const GLfloat *matrix);
      void loadPathRenderingIdentityMatrix(GLenum matrixMode);
      void stencilFillPath(GLuint path, GLenum fillMode, GLuint mask);
      void stencilStrokePath(GLuint path, GLint reference, GLuint mask);
      void coverFillPath(GLuint path, GLenum coverMode);
      void coverStrokePath(GLuint path, GLenum coverMode);
      void stencilThenCoverFillPath(GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode);
      void stencilThenCoverStrokePath(GLuint path, GLint reference, GLuint mask, GLenum coverMode);
      void coverFillPathInstanced(GLsizei numPaths,
                                  GLenum pathNameType,
                                  const void *paths,
                                  GLuint pathBase,
                                  GLenum coverMode,
                                  GLenum transformType,
                                  const GLfloat *transformValues);
      void coverStrokePathInstanced(GLsizei numPaths,
                                    GLenum pathNameType,
                                    const void *paths,
                                    GLuint pathBase,
                                    GLenum coverMode,
                                    GLenum transformType,
                                    const GLfloat *transformValues);
      void stencilFillPathInstanced(GLsizei numPaths,
                                    GLenum pathNameType,
                                    const void *paths,
                                    GLuint pathBAse,
                                    GLenum fillMode,
                                    GLuint mask,
                                    GLenum transformType,
                                    const GLfloat *transformValues);
      void stencilStrokePathInstanced(GLsizei numPaths,
                                      GLenum pathNameType,
                                      const void *paths,
                                      GLuint pathBase,
                                      GLint reference,
                                      GLuint mask,
                                      GLenum transformType,
                                      const GLfloat *transformValues);
      void stencilThenCoverFillPathInstanced(GLsizei numPaths,
                                             GLenum pathNameType,
                                             const void *paths,
                                             GLuint pathBase,
                                             GLenum fillMode,
                                             GLuint mask,
                                             GLenum coverMode,
                                             GLenum transformType,
                                             const GLfloat *transformValues);
      void stencilThenCoverStrokePathInstanced(GLsizei numPaths,
                                               GLenum pathNameType,
                                               const void *paths,
                                               GLuint pathBase,
                                               GLint reference,
                                               GLuint mask,
                                               GLenum coverMode,
                                               GLenum transformType,
                                               const GLfloat *transformValues);
      void bindFragmentInputLocation(GLuint program, GLint location, const GLchar *name);
      void programPathFragmentInputGen(GLuint program,
                                       GLint location,
                                       GLenum genMode,
                                       GLint components,
                                       const GLfloat *coeffs);
  
      void bufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
      void bufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
      void attachShader(GLuint program, GLuint shader);
      void bindAttribLocation(GLuint program, GLuint index, const GLchar *name);
      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 texStorage2DMultisample(GLenum target,
                                   GLsizei samples,
                                   GLenum internalformat,
                                   GLsizei width,
                                   GLsizei height,
                                   GLboolean fixedsamplelocations);
  
      void getMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
  
      void copyBufferSubData(GLenum readTarget,
                             GLenum writeTarget,
                             GLintptr readOffset,
                             GLintptr writeOffset,
                             GLsizeiptr size);
  
      GLenum checkFramebufferStatus(GLenum target);
      void compileShader(GLuint shader);
      void deleteBuffers(GLsizei n, const GLuint *buffers);
      void deleteFramebuffers(GLsizei n, const GLuint *framebuffers);
      void deleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
      void deleteTextures(GLsizei n, const GLuint *textures);
      void detachShader(GLuint program, GLuint shader);
      void genBuffers(GLsizei n, GLuint *buffers);
      void genFramebuffers(GLsizei n, GLuint *framebuffers);
      void genRenderbuffers(GLsizei n, GLuint *renderbuffers);
      void genTextures(GLsizei n, GLuint *textures);
      void getActiveAttrib(GLuint program,
                           GLuint index,
                           GLsizei bufsize,
                           GLsizei *length,
                           GLint *size,
                           GLenum *type,
                           GLchar *name);
      void getActiveUniform(GLuint program,
                            GLuint index,
                            GLsizei bufsize,
                            GLsizei *length,
                            GLint *size,
                            GLenum *type,
                            GLchar *name);
      void getAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders);
      GLint getAttribLocation(GLuint program, const GLchar *name);
      void getProgramiv(GLuint program, GLenum pname, GLint *params);
      void getProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length, GLchar *infolog);
      void getShaderiv(GLuint shader, GLenum pname, GLint *params);
      void getShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *infolog);
      void getShaderPrecisionFormat(GLenum shadertype,
                                    GLenum precisiontype,
                                    GLint *range,
                                    GLint *precision);
      void getShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *source);
      void getUniformfv(GLuint program, GLint location, GLfloat *params);
      void getUniformiv(GLuint program, GLint location, GLint *params);
      GLint getUniformLocation(GLuint program, const GLchar *name);
      GLboolean isBuffer(GLuint buffer);
      GLboolean isEnabled(GLenum cap);
      GLboolean isFramebuffer(GLuint framebuffer);
      GLboolean isProgram(GLuint program);
      GLboolean isRenderbuffer(GLuint renderbuffer);
      GLboolean isShader(GLuint shader);
      GLboolean isTexture(GLuint texture);
      void linkProgram(GLuint program);
      void releaseShaderCompiler();
      void shaderBinary(GLsizei n,
                        const GLuint *shaders,
                        GLenum binaryformat,
                        const void *binary,
                        GLsizei length);
      void shaderSource(GLuint shader,
                        GLsizei count,
                        const GLchar *const *string,
                        const GLint *length);
      void stencilFunc(GLenum func, GLint ref, GLuint mask);
      void stencilMask(GLuint mask);
      void stencilOp(GLenum fail, GLenum zfail, GLenum zpass);
      void uniform1f(GLint location, GLfloat x);
      void uniform1fv(GLint location, GLsizei count, const GLfloat *v);
      void uniform1i(GLint location, GLint x);
      void uniform1iv(GLint location, GLsizei count, const GLint *v);
      void uniform2f(GLint location, GLfloat x, GLfloat y);
      void uniform2fv(GLint location, GLsizei count, const GLfloat *v);
      void uniform2i(GLint location, GLint x, GLint y);
      void uniform2iv(GLint location, GLsizei count, const GLint *v);
      void uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
      void uniform3fv(GLint location, GLsizei count, const GLfloat *v);
      void uniform3i(GLint location, GLint x, GLint y, GLint z);
      void uniform3iv(GLint location, GLsizei count, const GLint *v);
      void uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
      void uniform4fv(GLint location, GLsizei count, const GLfloat *v);
      void uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
      void uniform4iv(GLint location, GLsizei count, const GLint *v);
      void uniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
      void uniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
      void uniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
      void validateProgram(GLuint program);
  
      void getProgramBinary(GLuint program,
                            GLsizei bufSize,
                            GLsizei *length,
                            GLenum *binaryFormat,
                            void *binary);
      void programBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
  
      // Returns the error.
      Error handleError(const Error &error) override;
  
      GLenum getError();
      void markContextLost();
      bool isContextLost();
      GLenum getResetStatus();
      bool isResetNotificationEnabled();
  
      const egl::Config *getConfig() const;
      EGLenum getClientType() const;
      EGLenum getRenderBuffer() const;
  
      const GLubyte *getString(GLenum name) const;
      const GLubyte *getStringi(GLenum name, GLuint index) const;
  
      size_t getExtensionStringCount() const;
  
      void requestExtension(const char *name);
      size_t getRequestableExtensionStringCount() const;
  
      rx::ContextImpl *getImplementation() const { return mImplementation.get(); }
      const Workarounds &getWorkarounds() const;
  
      void getFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
      void setFramebufferParameteri(GLenum target, GLenum pname, GLint param);
  
      Error getScratchBuffer(size_t requestedSizeBytes, angle::MemoryBuffer **scratchBufferOut) const;
      Error getZeroFilledBuffer(size_t requstedSizeBytes, angle::MemoryBuffer **zeroBufferOut) const;
  
      void dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
  
      MemoryProgramCache *getMemoryProgramCache() const { return mMemoryProgramCache; }
  
      template <EntryPoint EP, typename... ParamsT>
      void gatherParams(ParamsT &&... params);
  
      void texStorage2D(GLenum target,
                        GLsizei levels,
                        GLenum internalFormat,
                        GLsizei width,
                        GLsizei height);
      void texStorage3D(GLenum target,
                        GLsizei levels,
                        GLenum internalFormat,
                        GLsizei width,
                        GLsizei height,
                        GLsizei depth);
  
      egl::Display *getCurrentDisplay() const { return mCurrentDisplay; }
      egl::Surface *getCurrentDrawSurface() const { return mCurrentSurface; }
      egl::Surface *getCurrentReadSurface() const { return mCurrentSurface; }
  
    private:
      Error prepareForDraw(GLenum drawMode);
      void syncRendererState();
      void syncRendererState(const State::DirtyBits &bitMask, const State::DirtyObjects &objectMask);
      void syncStateForReadPixels();
      void syncStateForTexImage();
      void syncStateForClear();
      void syncStateForBlit();
      VertexArray *checkVertexArrayAllocation(GLuint vertexArrayHandle);
      TransformFeedback *checkTransformFeedbackAllocation(GLuint transformFeedback);
  
      void detachBuffer(GLuint buffer);
      void detachTexture(GLuint texture);
      void detachFramebuffer(GLuint framebuffer);
      void detachRenderbuffer(GLuint renderbuffer);
      void detachVertexArray(GLuint vertexArray);
      void detachTransformFeedback(GLuint transformFeedback);
      void detachSampler(GLuint sampler);
  
      void initRendererString();
      void initVersionStrings();
      void initExtensionStrings();
  
      void initCaps(const egl::DisplayExtensions &displayExtensions);
      void updateCaps();
      void initWorkarounds();
  
      LabeledObject *getLabeledObject(GLenum identifier, GLuint name) const;
      LabeledObject *getLabeledObjectFromPtr(const void *ptr) const;
  
      std::unique_ptr<rx::ContextImpl> mImplementation;
  
      // Caps to use for validation
      Caps mCaps;
      TextureCapsMap mTextureCaps;
      Extensions mExtensions;
      Limitations mLimitations;
  
      // Shader compiler. Lazily initialized hence the mutable value.
      mutable BindingPointer<Compiler> mCompiler;
  
      State mGLState;
  
      const egl::Config *mConfig;
      EGLenum mClientType;
  
      TextureMap mZeroTextures;
  
      ResourceMap<FenceNV> mFenceNVMap;
      HandleAllocator mFenceNVHandleAllocator;
  
      ResourceMap<Query> mQueryMap;
      HandleAllocator mQueryHandleAllocator;
  
      ResourceMap<VertexArray> mVertexArrayMap;
      HandleAllocator mVertexArrayHandleAllocator;
  
      ResourceMap<TransformFeedback> mTransformFeedbackMap;
      HandleAllocator mTransformFeedbackHandleAllocator;
  
      const char *mVersionString;
      const char *mShadingLanguageString;
      const char *mRendererString;
      const char *mExtensionString;
      std::vector<const char *> mExtensionStrings;
      const char *mRequestableExtensionString;
      std::vector<const char *> mRequestableExtensionStrings;
  
      // Recorded errors
      typedef std::set<GLenum> ErrorSet;
      ErrorSet mErrors;
  
      // Current/lost context flags
      bool mHasBeenCurrent;
      bool mContextLost;
      GLenum mResetStatus;
      bool mContextLostForced;
      GLenum mResetStrategy;
      bool mRobustAccess;
      egl::Surface *mCurrentSurface;
      egl::Display *mCurrentDisplay;
      Framebuffer *mSurfacelessFramebuffer;
      bool mWebGLContext;
      MemoryProgramCache *mMemoryProgramCache;
  
      State::DirtyBits mTexImageDirtyBits;
      State::DirtyObjects mTexImageDirtyObjects;
      State::DirtyBits mReadPixelsDirtyBits;
      State::DirtyObjects mReadPixelsDirtyObjects;
      State::DirtyBits mClearDirtyBits;
      State::DirtyObjects mClearDirtyObjects;
      State::DirtyBits mBlitDirtyBits;
      State::DirtyObjects mBlitDirtyObjects;
  
      Workarounds mWorkarounds;
  
      // Not really a property of context state. The size and contexts change per-api-call.
      mutable angle::ScratchBuffer mScratchBuffer;
      mutable angle::ScratchBuffer mZeroFilledBuffer;
  };
  
  template <EntryPoint EP, typename... ArgsT>
  ANGLE_INLINE void Context::gatherParams(ArgsT &&... args)
  {
      static_assert(sizeof(EntryPointParamType<EP>) <= kParamsBufferSize,
                    "Params struct too large, please increase kParamsBufferSize.");
  
      mSavedArgsType = &EntryPointParamType<EP>::TypeInfo;
  
      // Skip doing any work for ParamsBase/Invalid type.
      if (!EntryPointParamType<EP>::TypeInfo.isValid())
      {
          return;
      }
  
      EntryPointParamType<EP> *objBuffer =
          reinterpret_cast<EntryPointParamType<EP> *>(mParamsBuffer.data());
      EntryPointParamType<EP>::template Factory<EP>(objBuffer, this, std::forward<ArgsT>(args)...);
  }
  
  }  // namespace gl
  
  #endif  // LIBANGLE_CONTEXT_H_