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

• Show log

  Commit

• Hash : 02df796f
  Author :
  Date : 2015-07-01T10:03:42
  

  Centralize renderer limitations for non-conformant renderers
  
  Some renderer configurations (e.g. D3D11 Feature Level 9_3) have
  some limitations and aren't quite conformant. This change
  generates errors when applications hit these limitations, and
  informs developers that they must work around them.
  
  BUG=angleproject:1055
  
  Change-Id: I6a4a9e5cc71288ca366a54c769ca0eb82e79a7f7
  Reviewed-on: https://chromium-review.googlesource.com/282814
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/Context.cpp

• //
  // 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.cpp: Implements the gl::Context class, managing all GL state and performing
  // rendering operations. It is the GLES2 specific implementation of EGLContext.
  
  #include "libANGLE/Context.h"
  
  #include <iterator>
  #include <sstream>
  
  #include "common/platform.h"
  #include "common/utilities.h"
  #include "libANGLE/Buffer.h"
  #include "libANGLE/Compiler.h"
  #include "libANGLE/Display.h"
  #include "libANGLE/Fence.h"
  #include "libANGLE/Framebuffer.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/Program.h"
  #include "libANGLE/Query.h"
  #include "libANGLE/Renderbuffer.h"
  #include "libANGLE/ResourceManager.h"
  #include "libANGLE/Sampler.h"
  #include "libANGLE/Surface.h"
  #include "libANGLE/Texture.h"
  #include "libANGLE/TransformFeedback.h"
  #include "libANGLE/VertexArray.h"
  #include "libANGLE/formatutils.h"
  #include "libANGLE/validationES.h"
  #include "libANGLE/renderer/Renderer.h"
  
  namespace gl
  {
  
  Context::Context(const egl::Config *config, int clientVersion, const Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess)
      : mRenderer(renderer),
        mConfig(config),
        mData(clientVersion, mState, mCaps, mTextureCaps, mExtensions, nullptr)
  {
      ASSERT(robustAccess == false);   // Unimplemented
  
      initCaps(clientVersion);
      mState.initialize(mCaps, clientVersion);
  
      mClientVersion = clientVersion;
  
      mClientType = EGL_OPENGL_ES_API;
  
      mFenceNVHandleAllocator.setBaseHandle(0);
  
      if (shareContext != NULL)
      {
          mResourceManager = shareContext->mResourceManager;
          mResourceManager->addRef();
      }
      else
      {
          mResourceManager = new ResourceManager(mRenderer);
      }
  
      mData.resourceManager = mResourceManager;
  
      // [OpenGL ES 2.0.24] section 3.7 page 83:
      // In the initial state, TEXTURE_2D and TEXTURE_CUBE_MAP have twodimensional
      // and cube map texture state vectors respectively associated with them.
      // In order that access to these initial textures not be lost, they are treated as texture
      // objects all of whose names are 0.
  
      Texture *zeroTexture2D = new Texture(mRenderer->createTexture(GL_TEXTURE_2D), 0, GL_TEXTURE_2D);
      mZeroTextures[GL_TEXTURE_2D].set(zeroTexture2D);
  
      Texture *zeroTextureCube = new Texture(mRenderer->createTexture(GL_TEXTURE_CUBE_MAP), 0, GL_TEXTURE_CUBE_MAP);
      mZeroTextures[GL_TEXTURE_CUBE_MAP].set(zeroTextureCube);
  
      if (mClientVersion >= 3)
      {
          // TODO: These could also be enabled via extension
          Texture *zeroTexture3D = new Texture(mRenderer->createTexture(GL_TEXTURE_3D), 0, GL_TEXTURE_3D);
          mZeroTextures[GL_TEXTURE_3D].set(zeroTexture3D);
  
          Texture *zeroTexture2DArray = new Texture(mRenderer->createTexture(GL_TEXTURE_2D_ARRAY), 0, GL_TEXTURE_2D_ARRAY);
          mZeroTextures[GL_TEXTURE_2D_ARRAY].set(zeroTexture2DArray);
      }
  
      mState.initializeZeroTextures(mZeroTextures);
  
      // Allocate default FBO
      mFramebufferMap[0] = new Framebuffer(mCaps, mRenderer, 0);
  
      bindVertexArray(0);
      bindArrayBuffer(0);
      bindElementArrayBuffer(0);
  
      bindReadFramebuffer(0);
      bindDrawFramebuffer(0);
      bindRenderbuffer(0);
  
      bindGenericUniformBuffer(0);
      for (unsigned int i = 0; i < mCaps.maxCombinedUniformBlocks; i++)
      {
          bindIndexedUniformBuffer(0, i, 0, -1);
      }
  
      bindCopyReadBuffer(0);
      bindCopyWriteBuffer(0);
      bindPixelPackBuffer(0);
      bindPixelUnpackBuffer(0);
  
      // [OpenGL ES 3.0.2] section 2.14.1 pg 85:
      // In the initial state, a default transform feedback object is bound and treated as
      // a transform feedback object with a name of zero. That object is bound any time
      // BindTransformFeedback is called with id of zero
      mTransformFeedbackZero.set(new TransformFeedback(mRenderer->createTransformFeedback(), 0, mCaps));
      bindTransformFeedback(0);
  
      mHasBeenCurrent = false;
      mContextLost = false;
      mResetStatus = GL_NO_ERROR;
      mResetStrategy = (notifyResets ? GL_LOSE_CONTEXT_ON_RESET_EXT : GL_NO_RESET_NOTIFICATION_EXT);
      mRobustAccess = robustAccess;
  
      mCompiler = new Compiler(mRenderer->createCompiler(getData()));
  }
  
  Context::~Context()
  {
      mState.reset();
  
      while (!mFramebufferMap.empty())
      {
          // Delete the framebuffer in reverse order to destroy the framebuffer zero last.
          deleteFramebuffer(mFramebufferMap.rbegin()->first);
      }
  
      while (!mFenceNVMap.empty())
      {
          deleteFenceNV(mFenceNVMap.begin()->first);
      }
  
      while (!mQueryMap.empty())
      {
          deleteQuery(mQueryMap.begin()->first);
      }
  
      while (!mVertexArrayMap.empty())
      {
          deleteVertexArray(mVertexArrayMap.begin()->first);
      }
  
      mTransformFeedbackZero.set(NULL);
      while (!mTransformFeedbackMap.empty())
      {
          deleteTransformFeedback(mTransformFeedbackMap.begin()->first);
      }
  
      for (auto &zeroTexture : mZeroTextures)
      {
          zeroTexture.second.set(NULL);
      }
      mZeroTextures.clear();
  
      if (mResourceManager)
      {
          mResourceManager->release();
      }
  
      SafeDelete(mCompiler);
  }
  
  void Context::makeCurrent(egl::Surface *surface)
  {
      ASSERT(surface != nullptr);
  
      if (!mHasBeenCurrent)
      {
          initRendererString();
          initExtensionStrings();
  
          mState.setViewportParams(0, 0, surface->getWidth(), surface->getHeight());
          mState.setScissorParams(0, 0, surface->getWidth(), surface->getHeight());
  
          mHasBeenCurrent = true;
      }
  
      // Update default framebuffer
      Framebuffer *defaultFBO = mFramebufferMap[0];
  
      GLenum drawBufferState = GL_BACK;
      defaultFBO->setDrawBuffers(1, &drawBufferState);
      defaultFBO->setReadBuffer(GL_BACK);
  
      const FramebufferAttachment *backAttachment = defaultFBO->getAttachment(GL_BACK);
  
      if (backAttachment && backAttachment->getSurface() == surface)
      {
          // FBO already initialized to the surface.
          return;
      }
  
      const egl::Config *config = surface->getConfig();
  
      defaultFBO->setAttachment(GL_FRAMEBUFFER_DEFAULT, GL_BACK, ImageIndex::MakeInvalid(), surface);
  
      if (config->depthSize > 0)
      {
          defaultFBO->setAttachment(GL_FRAMEBUFFER_DEFAULT, GL_DEPTH, ImageIndex::MakeInvalid(), surface);
      }
      else
      {
          defaultFBO->resetAttachment(GL_DEPTH);
      }
  
      if (config->stencilSize > 0)
      {
          defaultFBO->setAttachment(GL_FRAMEBUFFER_DEFAULT, GL_STENCIL, ImageIndex::MakeInvalid(), surface);
      }
      else
      {
          defaultFBO->resetAttachment(GL_STENCIL);
      }
  }
  
  void Context::releaseSurface()
  {
      Framebuffer *defaultFBO = mFramebufferMap[0];
      defaultFBO->resetAttachment(GL_BACK);
      defaultFBO->resetAttachment(GL_DEPTH);
      defaultFBO->resetAttachment(GL_STENCIL);
  }
  
  // NOTE: this function should not assume that this context is current!
  void Context::markContextLost()
  {
      if (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT)
          mResetStatus = GL_UNKNOWN_CONTEXT_RESET_EXT;
      mContextLost = true;
  }
  
  bool Context::isContextLost()
  {
      return mContextLost;
  }
  
  GLuint Context::createBuffer()
  {
      return mResourceManager->createBuffer();
  }
  
  GLuint Context::createProgram()
  {
      return mResourceManager->createProgram();
  }
  
  GLuint Context::createShader(GLenum type)
  {
      return mResourceManager->createShader(getData(), type);
  }
  
  GLuint Context::createTexture()
  {
      return mResourceManager->createTexture();
  }
  
  GLuint Context::createRenderbuffer()
  {
      return mResourceManager->createRenderbuffer();
  }
  
  GLsync Context::createFenceSync()
  {
      GLuint handle = mResourceManager->createFenceSync();
  
      return reinterpret_cast<GLsync>(static_cast<uintptr_t>(handle));
  }
  
  GLuint Context::createVertexArray()
  {
      GLuint handle = mVertexArrayHandleAllocator.allocate();
  
      // Although the spec states VAO state is not initialized until the object is bound,
      // we create it immediately. The resulting behaviour is transparent to the application,
      // since it's not currently possible to access the state until the object is bound.
      VertexArray *vertexArray = new VertexArray(mRenderer, handle, MAX_VERTEX_ATTRIBS);
      mVertexArrayMap[handle] = vertexArray;
      return handle;
  }
  
  GLuint Context::createSampler()
  {
      return mResourceManager->createSampler();
  }
  
  GLuint Context::createTransformFeedback()
  {
      GLuint handle = mTransformFeedbackAllocator.allocate();
      TransformFeedback *transformFeedback = new TransformFeedback(mRenderer->createTransformFeedback(), handle, mCaps);
      transformFeedback->addRef();
      mTransformFeedbackMap[handle] = transformFeedback;
      return handle;
  }
  
  // Returns an unused framebuffer name
  GLuint Context::createFramebuffer()
  {
      GLuint handle = mFramebufferHandleAllocator.allocate();
  
      mFramebufferMap[handle] = NULL;
  
      return handle;
  }
  
  GLuint Context::createFenceNV()
  {
      GLuint handle = mFenceNVHandleAllocator.allocate();
  
      mFenceNVMap[handle] = new FenceNV(mRenderer->createFenceNV());
  
      return handle;
  }
  
  // Returns an unused query name
  GLuint Context::createQuery()
  {
      GLuint handle = mQueryHandleAllocator.allocate();
  
      mQueryMap[handle] = NULL;
  
      return handle;
  }
  
  void Context::deleteBuffer(GLuint buffer)
  {
      if (mResourceManager->getBuffer(buffer))
      {
          detachBuffer(buffer);
      }
  
      mResourceManager->deleteBuffer(buffer);
  }
  
  void Context::deleteShader(GLuint shader)
  {
      mResourceManager->deleteShader(shader);
  }
  
  void Context::deleteProgram(GLuint program)
  {
      mResourceManager->deleteProgram(program);
  }
  
  void Context::deleteTexture(GLuint texture)
  {
      if (mResourceManager->getTexture(texture))
      {
          detachTexture(texture);
      }
  
      mResourceManager->deleteTexture(texture);
  }
  
  void Context::deleteRenderbuffer(GLuint renderbuffer)
  {
      if (mResourceManager->getRenderbuffer(renderbuffer))
      {
          detachRenderbuffer(renderbuffer);
      }
  
      mResourceManager->deleteRenderbuffer(renderbuffer);
  }
  
  void Context::deleteFenceSync(GLsync fenceSync)
  {
      // The spec specifies the underlying Fence object is not deleted until all current
      // wait commands finish. However, since the name becomes invalid, we cannot query the fence,
      // and since our API is currently designed for being called from a single thread, we can delete
      // the fence immediately.
      mResourceManager->deleteFenceSync(static_cast<GLuint>(reinterpret_cast<uintptr_t>(fenceSync)));
  }
  
  void Context::deleteVertexArray(GLuint vertexArray)
  {
      auto vertexArrayObject = mVertexArrayMap.find(vertexArray);
  
      if (vertexArrayObject != mVertexArrayMap.end())
      {
          detachVertexArray(vertexArray);
  
          mVertexArrayHandleAllocator.release(vertexArrayObject->first);
          delete vertexArrayObject->second;
          mVertexArrayMap.erase(vertexArrayObject);
      }
  }
  
  void Context::deleteSampler(GLuint sampler)
  {
      if (mResourceManager->getSampler(sampler))
      {
          detachSampler(sampler);
      }
  
      mResourceManager->deleteSampler(sampler);
  }
  
  void Context::deleteTransformFeedback(GLuint transformFeedback)
  {
      auto iter = mTransformFeedbackMap.find(transformFeedback);
      if (iter != mTransformFeedbackMap.end())
      {
          detachTransformFeedback(transformFeedback);
          mTransformFeedbackAllocator.release(transformFeedback);
          iter->second->release();
          mTransformFeedbackMap.erase(iter);
      }
  }
  
  void Context::deleteFramebuffer(GLuint framebuffer)
  {
      FramebufferMap::iterator framebufferObject = mFramebufferMap.find(framebuffer);
  
      if (framebufferObject != mFramebufferMap.end())
      {
          detachFramebuffer(framebuffer);
  
          mFramebufferHandleAllocator.release(framebufferObject->first);
          delete framebufferObject->second;
          mFramebufferMap.erase(framebufferObject);
      }
  }
  
  void Context::deleteFenceNV(GLuint fence)
  {
      FenceNVMap::iterator fenceObject = mFenceNVMap.find(fence);
  
      if (fenceObject != mFenceNVMap.end())
      {
          mFenceNVHandleAllocator.release(fenceObject->first);
          delete fenceObject->second;
          mFenceNVMap.erase(fenceObject);
      }
  }
  
  void Context::deleteQuery(GLuint query)
  {
      QueryMap::iterator queryObject = mQueryMap.find(query);
      if (queryObject != mQueryMap.end())
      {
          mQueryHandleAllocator.release(queryObject->first);
          if (queryObject->second)
          {
              queryObject->second->release();
          }
          mQueryMap.erase(queryObject);
      }
  }
  
  Buffer *Context::getBuffer(GLuint handle)
  {
      return mResourceManager->getBuffer(handle);
  }
  
  Shader *Context::getShader(GLuint handle) const
  {
      return mResourceManager->getShader(handle);
  }
  
  Program *Context::getProgram(GLuint handle) const
  {
      return mResourceManager->getProgram(handle);
  }
  
  Texture *Context::getTexture(GLuint handle) const
  {
      return mResourceManager->getTexture(handle);
  }
  
  Renderbuffer *Context::getRenderbuffer(GLuint handle)
  {
      return mResourceManager->getRenderbuffer(handle);
  }
  
  FenceSync *Context::getFenceSync(GLsync handle) const
  {
      return mResourceManager->getFenceSync(static_cast<GLuint>(reinterpret_cast<uintptr_t>(handle)));
  }
  
  VertexArray *Context::getVertexArray(GLuint handle) const
  {
      auto vertexArray = mVertexArrayMap.find(handle);
  
      if (vertexArray == mVertexArrayMap.end())
      {
          return NULL;
      }
      else
      {
          return vertexArray->second;
      }
  }
  
  Sampler *Context::getSampler(GLuint handle) const
  {
      return mResourceManager->getSampler(handle);
  }
  
  TransformFeedback *Context::getTransformFeedback(GLuint handle) const
  {
      if (handle == 0)
      {
          return mTransformFeedbackZero.get();
      }
      else
      {
          TransformFeedbackMap::const_iterator iter = mTransformFeedbackMap.find(handle);
          return (iter != mTransformFeedbackMap.end()) ? iter->second : NULL;
      }
  }
  
  bool Context::isSampler(GLuint samplerName) const
  {
      return mResourceManager->isSampler(samplerName);
  }
  
  void Context::bindArrayBuffer(unsigned int buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.setArrayBufferBinding(getBuffer(buffer));
  }
  
  void Context::bindElementArrayBuffer(unsigned int buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.getVertexArray()->setElementArrayBuffer(getBuffer(buffer));
  }
  
  void Context::bindTexture(GLenum target, GLuint handle)
  {
      Texture *texture = NULL;
  
      if (handle == 0)
      {
          texture = mZeroTextures[target].get();
      }
      else
      {
          mResourceManager->checkTextureAllocation(handle, target);
          texture = getTexture(handle);
      }
  
      ASSERT(texture);
  
      mState.setSamplerTexture(target, texture);
  }
  
  void Context::bindReadFramebuffer(GLuint framebuffer)
  {
      if (!getFramebuffer(framebuffer))
      {
          mFramebufferMap[framebuffer] = new Framebuffer(mCaps, mRenderer, framebuffer);
      }
  
      mState.setReadFramebufferBinding(getFramebuffer(framebuffer));
  }
  
  void Context::bindDrawFramebuffer(GLuint framebuffer)
  {
      if (!getFramebuffer(framebuffer))
      {
          mFramebufferMap[framebuffer] = new Framebuffer(mCaps, mRenderer, framebuffer);
      }
  
      mState.setDrawFramebufferBinding(getFramebuffer(framebuffer));
  }
  
  void Context::bindRenderbuffer(GLuint renderbuffer)
  {
      mResourceManager->checkRenderbufferAllocation(renderbuffer);
  
      mState.setRenderbufferBinding(getRenderbuffer(renderbuffer));
  }
  
  void Context::bindVertexArray(GLuint vertexArray)
  {
      if (!getVertexArray(vertexArray))
      {
          VertexArray *vertexArrayObject = new VertexArray(mRenderer, vertexArray, MAX_VERTEX_ATTRIBS);
          mVertexArrayMap[vertexArray] = vertexArrayObject;
      }
  
      mState.setVertexArrayBinding(getVertexArray(vertexArray));
  }
  
  void Context::bindSampler(GLuint textureUnit, GLuint sampler)
  {
      ASSERT(textureUnit < mCaps.maxCombinedTextureImageUnits);
      mResourceManager->checkSamplerAllocation(sampler);
  
      mState.setSamplerBinding(textureUnit, getSampler(sampler));
  }
  
  void Context::bindGenericUniformBuffer(GLuint buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.setGenericUniformBufferBinding(getBuffer(buffer));
  }
  
  void Context::bindIndexedUniformBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.setIndexedUniformBufferBinding(index, getBuffer(buffer), offset, size);
  }
  
  void Context::bindGenericTransformFeedbackBuffer(GLuint buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.getCurrentTransformFeedback()->bindGenericBuffer(getBuffer(buffer));
  }
  
  void Context::bindIndexedTransformFeedbackBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.getCurrentTransformFeedback()->bindIndexedBuffer(index, getBuffer(buffer), offset, size);
  }
  
  void Context::bindCopyReadBuffer(GLuint buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.setCopyReadBufferBinding(getBuffer(buffer));
  }
  
  void Context::bindCopyWriteBuffer(GLuint buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.setCopyWriteBufferBinding(getBuffer(buffer));
  }
  
  void Context::bindPixelPackBuffer(GLuint buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.setPixelPackBufferBinding(getBuffer(buffer));
  }
  
  void Context::bindPixelUnpackBuffer(GLuint buffer)
  {
      mResourceManager->checkBufferAllocation(buffer);
  
      mState.setPixelUnpackBufferBinding(getBuffer(buffer));
  }
  
  void Context::useProgram(GLuint program)
  {
      mState.setProgram(getProgram(program));
  }
  
  void Context::bindTransformFeedback(GLuint transformFeedback)
  {
      mState.setTransformFeedbackBinding(getTransformFeedback(transformFeedback));
  }
  
  Error Context::beginQuery(GLenum target, GLuint query)
  {
      Query *queryObject = getQuery(query, true, target);
      ASSERT(queryObject);
  
      // begin query
      Error error = queryObject->begin();
      if (error.isError())
      {
          return error;
      }
  
      // set query as active for specified target only if begin succeeded
      mState.setActiveQuery(target, queryObject);
  
      return Error(GL_NO_ERROR);
  }
  
  Error Context::endQuery(GLenum target)
  {
      Query *queryObject = mState.getActiveQuery(target);
      ASSERT(queryObject);
  
      gl::Error error = queryObject->end();
  
      // Always unbind the query, even if there was an error. This may delete the query object.
      mState.setActiveQuery(target, NULL);
  
      return error;
  }
  
  Framebuffer *Context::getFramebuffer(unsigned int handle) const
  {
      FramebufferMap::const_iterator framebuffer = mFramebufferMap.find(handle);
  
      if (framebuffer == mFramebufferMap.end())
      {
          return NULL;
      }
      else
      {
          return framebuffer->second;
      }
  }
  
  FenceNV *Context::getFenceNV(unsigned int handle)
  {
      FenceNVMap::iterator fence = mFenceNVMap.find(handle);
  
      if (fence == mFenceNVMap.end())
      {
          return NULL;
      }
      else
      {
          return fence->second;
      }
  }
  
  Query *Context::getQuery(unsigned int handle, bool create, GLenum type)
  {
      QueryMap::iterator query = mQueryMap.find(handle);
  
      if (query == mQueryMap.end())
      {
          return NULL;
      }
      else
      {
          if (!query->second && create)
          {
              query->second = new Query(mRenderer->createQuery(type), handle);
              query->second->addRef();
          }
          return query->second;
      }
  }
  
  Texture *Context::getTargetTexture(GLenum target) const
  {
      ASSERT(ValidTextureTarget(this, target));
  
      return getSamplerTexture(mState.getActiveSampler(), target);
  }
  
  Texture *Context::getSamplerTexture(unsigned int sampler, GLenum type) const
  {
      return mState.getSamplerTexture(sampler, type);
  }
  
  Compiler *Context::getCompiler() const
  {
      return mCompiler;
  }
  
  void Context::getBooleanv(GLenum pname, GLboolean *params)
  {
      switch (pname)
      {
        case GL_SHADER_COMPILER:           *params = GL_TRUE;                             break;
        case GL_CONTEXT_ROBUST_ACCESS_EXT: *params = mRobustAccess ? GL_TRUE : GL_FALSE;  break;
        default:
          mState.getBooleanv(pname, params);
          break;
      }
  }
  
  void Context::getFloatv(GLenum pname, GLfloat *params)
  {
      // Queries about context capabilities and maximums are answered by Context.
      // Queries about current GL state values are answered by State.
      switch (pname)
      {
        case GL_ALIASED_LINE_WIDTH_RANGE:
          params[0] = mCaps.minAliasedLineWidth;
          params[1] = mCaps.maxAliasedLineWidth;
          break;
        case GL_ALIASED_POINT_SIZE_RANGE:
          params[0] = mCaps.minAliasedPointSize;
          params[1] = mCaps.maxAliasedPointSize;
          break;
        case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
          ASSERT(mExtensions.textureFilterAnisotropic);
          *params = mExtensions.maxTextureAnisotropy;
          break;
        case GL_MAX_TEXTURE_LOD_BIAS:
          *params = mCaps.maxLODBias;
          break;
        default:
          mState.getFloatv(pname, params);
          break;
      }
  }
  
  void Context::getIntegerv(GLenum pname, GLint *params)
  {
      // Queries about context capabilities and maximums are answered by Context.
      // Queries about current GL state values are answered by State.
  
      switch (pname)
      {
        case GL_MAX_VERTEX_ATTRIBS:                       *params = mCaps.maxVertexAttributes;                            break;
        case GL_MAX_VERTEX_UNIFORM_VECTORS:               *params = mCaps.maxVertexUniformVectors;                        break;
        case GL_MAX_VERTEX_UNIFORM_COMPONENTS:            *params = mCaps.maxVertexUniformComponents;                     break;
        case GL_MAX_VARYING_VECTORS:                      *params = mCaps.maxVaryingVectors;                              break;
        case GL_MAX_VARYING_COMPONENTS:                   *params = mCaps.maxVertexOutputComponents;                      break;
        case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:         *params = mCaps.maxCombinedTextureImageUnits;                   break;
        case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:           *params = mCaps.maxVertexTextureImageUnits;                     break;
        case GL_MAX_TEXTURE_IMAGE_UNITS:                  *params = mCaps.maxTextureImageUnits;                           break;
        case GL_MAX_FRAGMENT_UNIFORM_VECTORS:             *params = mCaps.maxFragmentUniformVectors;                      break;
        case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:          *params = mCaps.maxFragmentInputComponents;                     break;
        case GL_MAX_RENDERBUFFER_SIZE:                    *params = mCaps.maxRenderbufferSize;                            break;
        case GL_MAX_COLOR_ATTACHMENTS_EXT:                *params = mCaps.maxColorAttachments;                            break;
        case GL_MAX_DRAW_BUFFERS_EXT:                     *params = mCaps.maxDrawBuffers;                                 break;
        //case GL_FRAMEBUFFER_BINDING:                    // now equivalent to GL_DRAW_FRAMEBUFFER_BINDING_ANGLE
        case GL_SUBPIXEL_BITS:                            *params = 4;                                                    break;
        case GL_MAX_TEXTURE_SIZE:                         *params = mCaps.max2DTextureSize;                               break;
        case GL_MAX_CUBE_MAP_TEXTURE_SIZE:                *params = mCaps.maxCubeMapTextureSize;                          break;
        case GL_MAX_3D_TEXTURE_SIZE:                      *params = mCaps.max3DTextureSize;                               break;
        case GL_MAX_ARRAY_TEXTURE_LAYERS:                 *params = mCaps.maxArrayTextureLayers;                          break;
        case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:          *params = mCaps.uniformBufferOffsetAlignment;                   break;
        case GL_MAX_UNIFORM_BUFFER_BINDINGS:              *params = mCaps.maxUniformBufferBindings;                       break;
        case GL_MAX_VERTEX_UNIFORM_BLOCKS:                *params = mCaps.maxVertexUniformBlocks;                         break;
        case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:              *params = mCaps.maxFragmentUniformBlocks;                       break;
        case GL_MAX_COMBINED_UNIFORM_BLOCKS:              *params = mCaps.maxCombinedTextureImageUnits;                   break;
        case GL_MAX_VERTEX_OUTPUT_COMPONENTS:             *params = mCaps.maxVertexOutputComponents;                      break;
        case GL_MAX_FRAGMENT_INPUT_COMPONENTS:            *params = mCaps.maxFragmentInputComponents;                     break;
        case GL_MIN_PROGRAM_TEXEL_OFFSET:                 *params = mCaps.minProgramTexelOffset;                          break;
        case GL_MAX_PROGRAM_TEXEL_OFFSET:                 *params = mCaps.maxProgramTexelOffset;                          break;
        case GL_MAJOR_VERSION:                            *params = mClientVersion;                                       break;
        case GL_MINOR_VERSION:                            *params = 0;                                                    break;
        case GL_MAX_ELEMENTS_INDICES:                     *params = mCaps.maxElementsIndices;                             break;
        case GL_MAX_ELEMENTS_VERTICES:                    *params = mCaps.maxElementsVertices;                            break;
        case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: *params = mCaps.maxTransformFeedbackInterleavedComponents; break;
        case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:       *params = mCaps.maxTransformFeedbackSeparateAttributes;    break;
        case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:    *params = mCaps.maxTransformFeedbackSeparateComponents;    break;
        case GL_NUM_COMPRESSED_TEXTURE_FORMATS:           *params = mCaps.compressedTextureFormats.size();                break;
        case GL_MAX_SAMPLES_ANGLE:                        *params = mCaps.maxSamples;                                     break;
        case GL_MAX_VIEWPORT_DIMS:
          {
              params[0] = mCaps.maxViewportWidth;
              params[1] = mCaps.maxViewportHeight;
          }
          break;
        case GL_COMPRESSED_TEXTURE_FORMATS:
          std::copy(mCaps.compressedTextureFormats.begin(), mCaps.compressedTextureFormats.end(), params);
          break;
        case GL_RESET_NOTIFICATION_STRATEGY_EXT:
          *params = mResetStrategy;
          break;
        case GL_NUM_SHADER_BINARY_FORMATS:
          *params = mCaps.shaderBinaryFormats.size();
          break;
        case GL_SHADER_BINARY_FORMATS:
          std::copy(mCaps.shaderBinaryFormats.begin(), mCaps.shaderBinaryFormats.end(), params);
          break;
        case GL_NUM_PROGRAM_BINARY_FORMATS:
          *params = mCaps.programBinaryFormats.size();
          break;
        case GL_PROGRAM_BINARY_FORMATS:
          std::copy(mCaps.programBinaryFormats.begin(), mCaps.programBinaryFormats.end(), params);
          break;
        case GL_NUM_EXTENSIONS:
          *params = static_cast<GLint>(mExtensionStrings.size());
          break;
        default:
          mState.getIntegerv(getData(), pname, params);
          break;
      }
  }
  
  void Context::getInteger64v(GLenum pname, GLint64 *params)
  {
      // Queries about context capabilities and maximums are answered by Context.
      // Queries about current GL state values are answered by State.
      switch (pname)
      {
        case GL_MAX_ELEMENT_INDEX:
          *params = mCaps.maxElementIndex;
          break;
        case GL_MAX_UNIFORM_BLOCK_SIZE:
          *params = mCaps.maxUniformBlockSize;
          break;
        case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
          *params = mCaps.maxCombinedVertexUniformComponents;
          break;
        case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
          *params = mCaps.maxCombinedFragmentUniformComponents;
          break;
        case GL_MAX_SERVER_WAIT_TIMEOUT:
          *params = mCaps.maxServerWaitTimeout;
          break;
        default:
          UNREACHABLE();
          break;
      }
  }
  
  bool Context::getIndexedIntegerv(GLenum target, GLuint index, GLint *data)
  {
      // Queries about context capabilities and maximums are answered by Context.
      // Queries about current GL state values are answered by State.
      // Indexed integer queries all refer to current state, so this function is a
      // mere passthrough.
      return mState.getIndexedIntegerv(target, index, data);
  }
  
  bool Context::getIndexedInteger64v(GLenum target, GLuint index, GLint64 *data)
  {
      // Queries about context capabilities and maximums are answered by Context.
      // Queries about current GL state values are answered by State.
      // Indexed integer queries all refer to current state, so this function is a
      // mere passthrough.
      return mState.getIndexedInteger64v(target, index, data);
  }
  
  bool Context::getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams)
  {
      if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT)
      {
          *type = GL_INT;
          *numParams = 1;
          return true;
      }
  
      // Please note: the query type returned for DEPTH_CLEAR_VALUE in this implementation
      // is FLOAT rather than INT, as would be suggested by the GL ES 2.0 spec. This is due
      // to the fact that it is stored internally as a float, and so would require conversion
      // if returned from Context::getIntegerv. Since this conversion is already implemented
      // in the case that one calls glGetIntegerv to retrieve a float-typed state variable, we
      // place DEPTH_CLEAR_VALUE with the floats. This should make no difference to the calling
      // application.
      switch (pname)
      {
        case GL_COMPRESSED_TEXTURE_FORMATS:
          {
              *type = GL_INT;
              *numParams = mCaps.compressedTextureFormats.size();
          }
          return true;
        case GL_PROGRAM_BINARY_FORMATS_OES:
          {
              *type = GL_INT;
              *numParams = mCaps.programBinaryFormats.size();
          }
          return true;
        case GL_SHADER_BINARY_FORMATS:
          {
              *type = GL_INT;
              *numParams = mCaps.shaderBinaryFormats.size();
          }
          return true;
  
        case GL_MAX_VERTEX_ATTRIBS:
        case GL_MAX_VERTEX_UNIFORM_VECTORS:
        case GL_MAX_VARYING_VECTORS:
        case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
        case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
        case GL_MAX_TEXTURE_IMAGE_UNITS:
        case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
        case GL_MAX_RENDERBUFFER_SIZE:
        case GL_MAX_COLOR_ATTACHMENTS_EXT:
        case GL_MAX_DRAW_BUFFERS_EXT:
        case GL_NUM_SHADER_BINARY_FORMATS:
        case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
        case GL_ARRAY_BUFFER_BINDING:
        //case GL_FRAMEBUFFER_BINDING: // equivalent to DRAW_FRAMEBUFFER_BINDING_ANGLE
        case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE:
        case GL_READ_FRAMEBUFFER_BINDING_ANGLE:
        case GL_RENDERBUFFER_BINDING:
        case GL_CURRENT_PROGRAM:
        case GL_PACK_ALIGNMENT:
        case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
        case GL_UNPACK_ALIGNMENT:
        case GL_GENERATE_MIPMAP_HINT:
        case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
        case GL_RED_BITS:
        case GL_GREEN_BITS:
        case GL_BLUE_BITS:
        case GL_ALPHA_BITS:
        case GL_DEPTH_BITS:
        case GL_STENCIL_BITS:
        case GL_ELEMENT_ARRAY_BUFFER_BINDING:
        case GL_CULL_FACE_MODE:
        case GL_FRONT_FACE:
        case GL_ACTIVE_TEXTURE:
        case GL_STENCIL_FUNC:
        case GL_STENCIL_VALUE_MASK:
        case GL_STENCIL_REF:
        case GL_STENCIL_FAIL:
        case GL_STENCIL_PASS_DEPTH_FAIL:
        case GL_STENCIL_PASS_DEPTH_PASS:
        case GL_STENCIL_BACK_FUNC:
        case GL_STENCIL_BACK_VALUE_MASK:
        case GL_STENCIL_BACK_REF:
        case GL_STENCIL_BACK_FAIL:
        case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
        case GL_STENCIL_BACK_PASS_DEPTH_PASS:
        case GL_DEPTH_FUNC:
        case GL_BLEND_SRC_RGB:
        case GL_BLEND_SRC_ALPHA:
        case GL_BLEND_DST_RGB:
        case GL_BLEND_DST_ALPHA:
        case GL_BLEND_EQUATION_RGB:
        case GL_BLEND_EQUATION_ALPHA:
        case GL_STENCIL_WRITEMASK:
        case GL_STENCIL_BACK_WRITEMASK:
        case GL_STENCIL_CLEAR_VALUE:
        case GL_SUBPIXEL_BITS:
        case GL_MAX_TEXTURE_SIZE:
        case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
        case GL_SAMPLE_BUFFERS:
        case GL_SAMPLES:
        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
        case GL_TEXTURE_BINDING_2D:
        case GL_TEXTURE_BINDING_CUBE_MAP:
        case GL_RESET_NOTIFICATION_STRATEGY_EXT:
        case GL_NUM_PROGRAM_BINARY_FORMATS_OES:
          {
              *type = GL_INT;
              *numParams = 1;
          }
          return true;
        case GL_MAX_SAMPLES_ANGLE:
          {
              if (mExtensions.framebufferMultisample)
              {
                  *type = GL_INT;
                  *numParams = 1;
              }
              else
              {
                  return false;
              }
          }
          return true;
        case GL_PIXEL_PACK_BUFFER_BINDING:
        case GL_PIXEL_UNPACK_BUFFER_BINDING:
          {
              if (mExtensions.pixelBufferObject)
              {
                  *type = GL_INT;
                  *numParams = 1;
              }
              else
              {
                  return false;
              }
          }
          return true;
        case GL_MAX_VIEWPORT_DIMS:
          {
              *type = GL_INT;
              *numParams = 2;
          }
          return true;
        case GL_VIEWPORT:
        case GL_SCISSOR_BOX:
          {
              *type = GL_INT;
              *numParams = 4;
          }
          return true;
        case GL_SHADER_COMPILER:
        case GL_SAMPLE_COVERAGE_INVERT:
        case GL_DEPTH_WRITEMASK:
        case GL_CULL_FACE:                // CULL_FACE through DITHER are natural to IsEnabled,
        case GL_POLYGON_OFFSET_FILL:      // but can be retrieved through the Get{Type}v queries.
        case GL_SAMPLE_ALPHA_TO_COVERAGE: // For this purpose, they are treated here as bool-natural
        case GL_SAMPLE_COVERAGE:
        case GL_SCISSOR_TEST:
        case GL_STENCIL_TEST:
        case GL_DEPTH_TEST:
        case GL_BLEND:
        case GL_DITHER:
        case GL_CONTEXT_ROBUST_ACCESS_EXT:
          {
              *type = GL_BOOL;
              *numParams = 1;
          }
          return true;
        case GL_COLOR_WRITEMASK:
          {
              *type = GL_BOOL;
              *numParams = 4;
          }
          return true;
        case GL_POLYGON_OFFSET_FACTOR:
        case GL_POLYGON_OFFSET_UNITS:
        case GL_SAMPLE_COVERAGE_VALUE:
        case GL_DEPTH_CLEAR_VALUE:
        case GL_LINE_WIDTH:
          {
              *type = GL_FLOAT;
              *numParams = 1;
          }
          return true;
        case GL_ALIASED_LINE_WIDTH_RANGE:
        case GL_ALIASED_POINT_SIZE_RANGE:
        case GL_DEPTH_RANGE:
          {
              *type = GL_FLOAT;
              *numParams = 2;
          }
          return true;
        case GL_COLOR_CLEAR_VALUE:
        case GL_BLEND_COLOR:
          {
              *type = GL_FLOAT;
              *numParams = 4;
          }
          return true;
        case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
          if (!mExtensions.maxTextureAnisotropy)
          {
              return false;
          }
          *type = GL_FLOAT;
          *numParams = 1;
          return true;
      }
  
      if (mClientVersion < 3)
      {
          return false;
      }
  
      // Check for ES3.0+ parameter names
      switch (pname)
      {
        case GL_MAX_UNIFORM_BUFFER_BINDINGS:
        case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
        case GL_UNIFORM_BUFFER_BINDING:
        case GL_TRANSFORM_FEEDBACK_BINDING:
        case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
        case GL_COPY_READ_BUFFER_BINDING:
        case GL_COPY_WRITE_BUFFER_BINDING:
        case GL_TEXTURE_BINDING_3D:
        case GL_TEXTURE_BINDING_2D_ARRAY:
        case GL_MAX_3D_TEXTURE_SIZE:
        case GL_MAX_ARRAY_TEXTURE_LAYERS:
        case GL_MAX_VERTEX_UNIFORM_BLOCKS:
        case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
        case GL_MAX_COMBINED_UNIFORM_BLOCKS:
        case GL_MAX_VERTEX_OUTPUT_COMPONENTS:
        case GL_MAX_FRAGMENT_INPUT_COMPONENTS:
        case GL_MAX_VARYING_COMPONENTS:
        case GL_VERTEX_ARRAY_BINDING:
        case GL_MAX_VERTEX_UNIFORM_COMPONENTS:
        case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
        case GL_MIN_PROGRAM_TEXEL_OFFSET:
        case GL_MAX_PROGRAM_TEXEL_OFFSET:
        case GL_NUM_EXTENSIONS:
        case GL_MAJOR_VERSION:
        case GL_MINOR_VERSION:
        case GL_MAX_ELEMENTS_INDICES:
        case GL_MAX_ELEMENTS_VERTICES:
        case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
        case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
        case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
          {
              *type = GL_INT;
              *numParams = 1;
          }
          return true;
  
        case GL_MAX_ELEMENT_INDEX:
        case GL_MAX_UNIFORM_BLOCK_SIZE:
        case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
        case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
        case GL_MAX_SERVER_WAIT_TIMEOUT:
          {
              *type = GL_INT_64_ANGLEX;
              *numParams = 1;
          }
          return true;
  
        case GL_TRANSFORM_FEEDBACK_ACTIVE:
        case GL_TRANSFORM_FEEDBACK_PAUSED:
          {
              *type = GL_BOOL;
              *numParams = 1;
          }
          return true;
  
        case GL_MAX_TEXTURE_LOD_BIAS:
          {
              *type = GL_FLOAT;
              *numParams = 1;
          }
          return true;
      }
  
      return false;
  }
  
  bool Context::getIndexedQueryParameterInfo(GLenum target, GLenum *type, unsigned int *numParams)
  {
      if (mClientVersion < 3)
      {
          return false;
      }
  
      switch (target)
      {
        case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
        case GL_UNIFORM_BUFFER_BINDING:
          {
              *type = GL_INT;
              *numParams = 1;
          }
          return true;
        case GL_TRANSFORM_FEEDBACK_BUFFER_START:
        case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
        case GL_UNIFORM_BUFFER_START:
        case GL_UNIFORM_BUFFER_SIZE:
          {
              *type = GL_INT_64_ANGLEX;
              *numParams = 1;
          }
      }
  
      return false;
  }
  
  Error Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances)
  {
      Error error = mRenderer->drawArrays(getData(), mode, first, count, instances);
      if (error.isError())
      {
          return error;
      }
  
      TransformFeedback *transformFeedback = mState.getCurrentTransformFeedback();
      if (transformFeedback->isActive() && !transformFeedback->isPaused())
      {
          for (size_t tfBufferIndex = 0; tfBufferIndex < transformFeedback->getIndexedBufferCount(); tfBufferIndex++)
          {
              const OffsetBindingPointer<Buffer> &buffer = transformFeedback->getIndexedBuffer(tfBufferIndex);
              if (buffer.get() != nullptr)
              {
                  buffer->onTransformFeedback();
              }
          }
      }
  
      return Error(GL_NO_ERROR);
  }
  
  Error Context::drawElements(GLenum mode, GLsizei count, GLenum type,
                              const GLvoid *indices, GLsizei instances,
                              const RangeUI &indexRange)
  {
      return mRenderer->drawElements(getData(), mode, count, type, indices, instances, indexRange);
  }
  
  Error Context::flush()
  {
      return mRenderer->flush();
  }
  
  Error Context::finish()
  {
      return mRenderer->finish();
  }
  
  void Context::insertEventMarker(GLsizei length, const char *marker)
  {
      ASSERT(mRenderer);
      mRenderer->insertEventMarker(length, marker);
  }
  
  void Context::pushGroupMarker(GLsizei length, const char *marker)
  {
      ASSERT(mRenderer);
      mRenderer->pushGroupMarker(length, marker);
  }
  
  void Context::popGroupMarker()
  {
      ASSERT(mRenderer);
      mRenderer->popGroupMarker();
  }
  
  void Context::recordError(const Error &error)
  {
      if (error.isError())
      {
          mErrors.insert(error.getCode());
      }
  }
  
  // Get one of the recorded errors and clear its flag, if any.
  // [OpenGL ES 2.0.24] section 2.5 page 13.
  GLenum Context::getError()
  {
      if (mErrors.empty())
      {
          return GL_NO_ERROR;
      }
      else
      {
          GLenum error = *mErrors.begin();
          mErrors.erase(mErrors.begin());
          return error;
      }
  }
  
  GLenum Context::getResetStatus()
  {
      //TODO(jmadill): needs MANGLE reworking
      if (mResetStatus == GL_NO_ERROR && !mContextLost)
      {
          // mResetStatus will be set by the markContextLost callback
          // in the case a notification is sent
          if (mRenderer->testDeviceLost())
          {
              mRenderer->notifyDeviceLost();
          }
      }
  
      GLenum status = mResetStatus;
  
      if (mResetStatus != GL_NO_ERROR)
      {
          ASSERT(mContextLost);
  
          if (mRenderer->testDeviceResettable())
          {
              mResetStatus = GL_NO_ERROR;
          }
      }
  
      return status;
  }
  
  bool Context::isResetNotificationEnabled()
  {
      return (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT);
  }
  
  int Context::getClientVersion() const
  {
      return mClientVersion;
  }
  
  const egl::Config *Context::getConfig() const
  {
      return mConfig;
  }
  
  EGLenum Context::getClientType() const
  {
      return mClientType;
  }
  
  EGLenum Context::getRenderBuffer() const
  {
      ASSERT(mFramebufferMap.count(0) > 0);
      const Framebuffer *framebuffer = mFramebufferMap.find(0)->second;
      const FramebufferAttachment *backAttachment = framebuffer->getAttachment(GL_BACK);
      return backAttachment ? backAttachment->getSurface()->getRenderBuffer() : EGL_NONE;
  }
  
  const Caps &Context::getCaps() const
  {
      return mCaps;
  }
  
  const TextureCapsMap &Context::getTextureCaps() const
  {
      return mTextureCaps;
  }
  
  const Extensions &Context::getExtensions() const
  {
      return mExtensions;
  }
  
  const Limitations &Context::getLimitations() const
  {
      return mLimitations;
  }
  
  void Context::detachTexture(GLuint texture)
  {
      // Simple pass-through to State's detachTexture method, as textures do not require
      // allocation map management either here or in the resource manager at detach time.
      // Zero textures are held by the Context, and we don't attempt to request them from
      // the State.
      mState.detachTexture(mZeroTextures, texture);
  }
  
  void Context::detachBuffer(GLuint buffer)
  {
      // Buffer detachment is handled by Context, because the buffer must also be
      // attached from any VAOs in existence, and Context holds the VAO map.
  
      // [OpenGL ES 2.0.24] section 2.9 page 22:
      // If a buffer object is deleted while it is bound, all bindings to that object in the current context
      // (i.e. in the thread that called Delete-Buffers) are reset to zero.
  
      mState.removeArrayBufferBinding(buffer);
  
      // mark as freed among the vertex array objects
      for (auto vaoIt = mVertexArrayMap.begin(); vaoIt != mVertexArrayMap.end(); vaoIt++)
      {
          vaoIt->second->detachBuffer(buffer);
      }
  }
  
  void Context::detachFramebuffer(GLuint framebuffer)
  {
      // Framebuffer detachment is handled by Context, because 0 is a valid
      // Framebuffer object, and a pointer to it must be passed from Context
      // to State at binding time.
  
      // [OpenGL ES 2.0.24] section 4.4 page 107:
      // If a framebuffer that is currently bound to the target FRAMEBUFFER is deleted, it is as though
      // BindFramebuffer had been executed with the target of FRAMEBUFFER and framebuffer of zero.
  
      if (mState.removeReadFramebufferBinding(framebuffer) && framebuffer != 0)
      {
          bindReadFramebuffer(0);
      }
  
      if (mState.removeDrawFramebufferBinding(framebuffer) && framebuffer != 0)
      {
          bindDrawFramebuffer(0);
      }
  }
  
  void Context::detachRenderbuffer(GLuint renderbuffer)
  {
      mState.detachRenderbuffer(renderbuffer);
  }
  
  void Context::detachVertexArray(GLuint vertexArray)
  {
      // Vertex array detachment is handled by Context, because 0 is a valid
      // VAO, and a pointer to it must be passed from Context to State at
      // binding time.
  
      // [OpenGL ES 3.0.2] section 2.10 page 43:
      // If a vertex array object that is currently bound is deleted, the binding
      // for that object reverts to zero and the default vertex array becomes current.
      if (mState.removeVertexArrayBinding(vertexArray))
      {
          bindVertexArray(0);
      }
  }
  
  void Context::detachTransformFeedback(GLuint transformFeedback)
  {
      mState.detachTransformFeedback(transformFeedback);
  }
  
  void Context::detachSampler(GLuint sampler)
  {
      mState.detachSampler(sampler);
  }
  
  void Context::setVertexAttribDivisor(GLuint index, GLuint divisor)
  {
      mState.getVertexArray()->setVertexAttribDivisor(index, divisor);
  }
  
  void Context::samplerParameteri(GLuint sampler, GLenum pname, GLint param)
  {
      mResourceManager->checkSamplerAllocation(sampler);
  
      Sampler *samplerObject = getSampler(sampler);
      ASSERT(samplerObject);
  
      switch (pname)
      {
        case GL_TEXTURE_MIN_FILTER:    samplerObject->setMinFilter(static_cast<GLenum>(param));       break;
        case GL_TEXTURE_MAG_FILTER:    samplerObject->setMagFilter(static_cast<GLenum>(param));       break;
        case GL_TEXTURE_WRAP_S:        samplerObject->setWrapS(static_cast<GLenum>(param));           break;
        case GL_TEXTURE_WRAP_T:        samplerObject->setWrapT(static_cast<GLenum>(param));           break;
        case GL_TEXTURE_WRAP_R:        samplerObject->setWrapR(static_cast<GLenum>(param));           break;
        case GL_TEXTURE_MIN_LOD:       samplerObject->setMinLod(static_cast<GLfloat>(param));         break;
        case GL_TEXTURE_MAX_LOD:       samplerObject->setMaxLod(static_cast<GLfloat>(param));         break;
        case GL_TEXTURE_COMPARE_MODE:  samplerObject->setComparisonMode(static_cast<GLenum>(param));  break;
        case GL_TEXTURE_COMPARE_FUNC:  samplerObject->setComparisonFunc(static_cast<GLenum>(param));  break;
        default:                       UNREACHABLE(); break;
      }
  }
  
  void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
  {
      mResourceManager->checkSamplerAllocation(sampler);
  
      Sampler *samplerObject = getSampler(sampler);
      ASSERT(samplerObject);
  
      switch (pname)
      {
        case GL_TEXTURE_MIN_FILTER:    samplerObject->setMinFilter(uiround<GLenum>(param));       break;
        case GL_TEXTURE_MAG_FILTER:    samplerObject->setMagFilter(uiround<GLenum>(param));       break;
        case GL_TEXTURE_WRAP_S:        samplerObject->setWrapS(uiround<GLenum>(param));           break;
        case GL_TEXTURE_WRAP_T:        samplerObject->setWrapT(uiround<GLenum>(param));           break;
        case GL_TEXTURE_WRAP_R:        samplerObject->setWrapR(uiround<GLenum>(param));           break;
        case GL_TEXTURE_MIN_LOD:       samplerObject->setMinLod(param);                           break;
        case GL_TEXTURE_MAX_LOD:       samplerObject->setMaxLod(param);                           break;
        case GL_TEXTURE_COMPARE_MODE:  samplerObject->setComparisonMode(uiround<GLenum>(param));  break;
        case GL_TEXTURE_COMPARE_FUNC:  samplerObject->setComparisonFunc(uiround<GLenum>(param));  break;
        default:                       UNREACHABLE(); break;
      }
  }
  
  GLint Context::getSamplerParameteri(GLuint sampler, GLenum pname)
  {
      mResourceManager->checkSamplerAllocation(sampler);
  
      Sampler *samplerObject = getSampler(sampler);
      ASSERT(samplerObject);
  
      switch (pname)
      {
        case GL_TEXTURE_MIN_FILTER:    return static_cast<GLint>(samplerObject->getMinFilter());
        case GL_TEXTURE_MAG_FILTER:    return static_cast<GLint>(samplerObject->getMagFilter());
        case GL_TEXTURE_WRAP_S:        return static_cast<GLint>(samplerObject->getWrapS());
        case GL_TEXTURE_WRAP_T:        return static_cast<GLint>(samplerObject->getWrapT());
        case GL_TEXTURE_WRAP_R:        return static_cast<GLint>(samplerObject->getWrapR());
        case GL_TEXTURE_MIN_LOD:       return uiround<GLint>(samplerObject->getMinLod());
        case GL_TEXTURE_MAX_LOD:       return uiround<GLint>(samplerObject->getMaxLod());
        case GL_TEXTURE_COMPARE_MODE:  return static_cast<GLint>(samplerObject->getComparisonMode());
        case GL_TEXTURE_COMPARE_FUNC:  return static_cast<GLint>(samplerObject->getComparisonFunc());
        default:                       UNREACHABLE(); return 0;
      }
  }
  
  GLfloat Context::getSamplerParameterf(GLuint sampler, GLenum pname)
  {
      mResourceManager->checkSamplerAllocation(sampler);
  
      Sampler *samplerObject = getSampler(sampler);
      ASSERT(samplerObject);
  
      switch (pname)
      {
        case GL_TEXTURE_MIN_FILTER:    return static_cast<GLfloat>(samplerObject->getMinFilter());
        case GL_TEXTURE_MAG_FILTER:    return static_cast<GLfloat>(samplerObject->getMagFilter());
        case GL_TEXTURE_WRAP_S:        return static_cast<GLfloat>(samplerObject->getWrapS());
        case GL_TEXTURE_WRAP_T:        return static_cast<GLfloat>(samplerObject->getWrapT());
        case GL_TEXTURE_WRAP_R:        return static_cast<GLfloat>(samplerObject->getWrapR());
        case GL_TEXTURE_MIN_LOD:       return samplerObject->getMinLod();
        case GL_TEXTURE_MAX_LOD:       return samplerObject->getMaxLod();
        case GL_TEXTURE_COMPARE_MODE:  return static_cast<GLfloat>(samplerObject->getComparisonMode());
        case GL_TEXTURE_COMPARE_FUNC:  return static_cast<GLfloat>(samplerObject->getComparisonFunc());
        default:                       UNREACHABLE(); return 0;
      }
  }
  
  void Context::initRendererString()
  {
      std::ostringstream rendererString;
      rendererString << "ANGLE (";
      rendererString << mRenderer->getRendererDescription();
      rendererString << ")";
  
      mRendererString = MakeStaticString(rendererString.str());
  }
  
  const std::string &Context::getRendererString() const
  {
      return mRendererString;
  }
  
  void Context::initExtensionStrings()
  {
      mExtensionStrings = mExtensions.getStrings();
  
      std::ostringstream combinedStringStream;
      std::copy(mExtensionStrings.begin(), mExtensionStrings.end(), std::ostream_iterator<std::string>(combinedStringStream, " "));
      mExtensionString = combinedStringStream.str();
  }
  
  const std::string &Context::getExtensionString() const
  {
      return mExtensionString;
  }
  
  const std::string &Context::getExtensionString(size_t idx) const
  {
      return mExtensionStrings[idx];
  }
  
  size_t Context::getExtensionStringCount() const
  {
      return mExtensionStrings.size();
  }
  
  void Context::initCaps(GLuint clientVersion)
  {
      mCaps = mRenderer->getRendererCaps();
  
      mExtensions = mRenderer->getRendererExtensions();
  
      mLimitations = mRenderer->getRendererLimitations();
  
      if (clientVersion < 3)
      {
          // Disable ES3+ extensions
          mExtensions.colorBufferFloat = false;
      }
  
      if (clientVersion > 2)
      {
          // FIXME(geofflang): Don't support EXT_sRGB in non-ES2 contexts
          //mExtensions.sRGB = false;
      }
  
      // Apply implementation limits
      mCaps.maxVertexAttributes = std::min<GLuint>(mCaps.maxVertexAttributes, MAX_VERTEX_ATTRIBS);
      mCaps.maxVertexUniformBlocks = std::min<GLuint>(mCaps.maxVertexUniformBlocks, IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS);
      mCaps.maxVertexOutputComponents = std::min<GLuint>(mCaps.maxVertexOutputComponents, IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
  
      mCaps.maxFragmentInputComponents = std::min<GLuint>(mCaps.maxFragmentInputComponents, IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
  
      mCaps.compressedTextureFormats.clear();
  
      const TextureCapsMap &rendererFormats = mRenderer->getRendererTextureCaps();
      for (TextureCapsMap::const_iterator i = rendererFormats.begin(); i != rendererFormats.end(); i++)
      {
          GLenum format = i->first;
          TextureCaps formatCaps = i->second;
  
          const InternalFormat &formatInfo = GetInternalFormatInfo(format);
  
          // Update the format caps based on the client version and extensions
          formatCaps.texturable = formatInfo.textureSupport(clientVersion, mExtensions);
          formatCaps.renderable = formatInfo.renderSupport(clientVersion, mExtensions);
          formatCaps.filterable = formatInfo.filterSupport(clientVersion, mExtensions);
  
          // OpenGL ES does not support multisampling with integer formats
          if (!formatInfo.renderSupport || formatInfo.componentType == GL_INT || formatInfo.componentType == GL_UNSIGNED_INT)
          {
              formatCaps.sampleCounts.clear();
          }
  
          if (formatCaps.texturable && formatInfo.compressed)
          {
              mCaps.compressedTextureFormats.push_back(format);
          }
  
          mTextureCaps.insert(format, formatCaps);
      }
  }
  
  }
  

Download