Google Git
Sign in
cobalt / cobalt / 02dc75a3e28204929da5793da854c523d59e642c / . / src / third_party / angle / src / libANGLE / Context.cpp
blob: 90e80d92b573c96eff7d9747669d5d6dd3943b47 [file] [log] [blame]
//
// Copyright 2002 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 "libANGLE/Context.inl.h"
#include <string.h>
#include <iterator>
#include <sstream>
#include <vector>
#include "common/PackedEnums.h"
#include "common/matrix_utils.h"
#include "common/platform.h"
#include "common/utilities.h"
#include "common/version.h"
#include "libANGLE/Buffer.h"
#include "libANGLE/Compiler.h"
#include "libANGLE/Display.h"
#include "libANGLE/Fence.h"
#include "libANGLE/FrameCapture.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/MemoryObject.h"
#include "libANGLE/Path.h"
#include "libANGLE/Program.h"
#include "libANGLE/ProgramPipeline.h"
#include "libANGLE/Query.h"
#include "libANGLE/Renderbuffer.h"
#include "libANGLE/ResourceManager.h"
#include "libANGLE/Sampler.h"
#include "libANGLE/Semaphore.h"
#include "libANGLE/Surface.h"
#include "libANGLE/Texture.h"
#include "libANGLE/TransformFeedback.h"
#include "libANGLE/VertexArray.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/queryconversions.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/renderer/DisplayImpl.h"
#include "libANGLE/renderer/Format.h"
#include "libANGLE/validationES.h"
namespace gl
{
namespace
{
template <typename T>
std::vector<Path *> GatherPaths(PathManager &resourceManager,
GLsizei numPaths,
const void *paths,
PathID pathBase)
{
std::vector<Path *> ret;
ret.reserve(numPaths);
const auto *nameArray = static_cast<const T *>(paths);
for (GLsizei i = 0; i < numPaths; ++i)
{
const GLuint pathName = nameArray[i] + pathBase.value;
ret.push_back(resourceManager.getPath({pathName}));
}
return ret;
}
std::vector<Path *> GatherPaths(PathManager &resourceManager,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase)
{
switch (pathNameType)
{
case GL_UNSIGNED_BYTE:
return GatherPaths<GLubyte>(resourceManager, numPaths, paths, pathBase);
case GL_BYTE:
return GatherPaths<GLbyte>(resourceManager, numPaths, paths, pathBase);
case GL_UNSIGNED_SHORT:
return GatherPaths<GLushort>(resourceManager, numPaths, paths, pathBase);
case GL_SHORT:
return GatherPaths<GLshort>(resourceManager, numPaths, paths, pathBase);
case GL_UNSIGNED_INT:
return GatherPaths<GLuint>(resourceManager, numPaths, paths, pathBase);
case GL_INT:
return GatherPaths<GLint>(resourceManager, numPaths, paths, pathBase);
}
UNREACHABLE();
return std::vector<Path *>();
}
template <typename T>
angle::Result GetQueryObjectParameter(const Context *context, Query *query, GLenum pname, T *params)
{
ASSERT(query != nullptr || pname == GL_QUERY_RESULT_AVAILABLE_EXT);
switch (pname)
{
case GL_QUERY_RESULT_EXT:
return query->getResult(context, params);
case GL_QUERY_RESULT_AVAILABLE_EXT:
{
bool available = false;
if (context->isContextLost())
{
available = true;
}
else
{
ANGLE_TRY(query->isResultAvailable(context, &available));
}
*params = CastFromStateValue<T>(pname, static_cast<GLuint>(available));
return angle::Result::Continue;
}
default:
UNREACHABLE();
return angle::Result::Stop;
}
}
// Attribute map queries.
EGLint GetClientMajorVersion(const egl::AttributeMap &attribs)
{
return static_cast<EGLint>(attribs.get(EGL_CONTEXT_CLIENT_VERSION, 1));
}
EGLint GetClientMinorVersion(const egl::AttributeMap &attribs)
{
return static_cast<EGLint>(attribs.get(EGL_CONTEXT_MINOR_VERSION, 0));
}
bool GetBackwardCompatibleContext(const egl::AttributeMap &attribs)
{
return attribs.get(EGL_CONTEXT_OPENGL_BACKWARDS_COMPATIBLE_ANGLE, EGL_TRUE) == EGL_TRUE;
}
Version GetClientVersion(egl::Display *display, const egl::AttributeMap &attribs)
{
Version requestedVersion =
Version(GetClientMajorVersion(attribs), GetClientMinorVersion(attribs));
if (GetBackwardCompatibleContext(attribs))
{
if (requestedVersion.major == 1)
{
// If the user requests an ES1 context, we cannot return an ES 2+ context.
return Version(1, 1);
}
else
{
// Always up the version to at least the max conformant version this display supports.
// Only return a higher client version if requested.
return std::max(display->getImplementation()->getMaxConformantESVersion(),
requestedVersion);
}
}
else
{
return requestedVersion;
}
}
GLenum GetResetStrategy(const egl::AttributeMap &attribs)
{
EGLAttrib attrib =
attribs.get(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_NO_RESET_NOTIFICATION);
switch (attrib)
{
case EGL_NO_RESET_NOTIFICATION:
return GL_NO_RESET_NOTIFICATION_EXT;
case EGL_LOSE_CONTEXT_ON_RESET:
return GL_LOSE_CONTEXT_ON_RESET_EXT;
default:
UNREACHABLE();
return GL_NONE;
}
}
bool GetRobustAccess(const egl::AttributeMap &attribs)
{
return (attribs.get(EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_FALSE) == EGL_TRUE) ||
((attribs.get(EGL_CONTEXT_FLAGS_KHR, 0) & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR) !=
0);
}
bool GetDebug(const egl::AttributeMap &attribs)
{
return (attribs.get(EGL_CONTEXT_OPENGL_DEBUG, EGL_FALSE) == EGL_TRUE) ||
((attribs.get(EGL_CONTEXT_FLAGS_KHR, 0) & EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR) != 0);
}
bool GetNoError(const egl::AttributeMap &attribs)
{
return (attribs.get(EGL_CONTEXT_OPENGL_NO_ERROR_KHR, EGL_FALSE) == EGL_TRUE);
}
bool GetWebGLContext(const egl::AttributeMap &attribs)
{
return (attribs.get(EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE, EGL_FALSE) == EGL_TRUE);
}
bool GetExtensionsEnabled(const egl::AttributeMap &attribs, bool webGLContext)
{
// If the context is WebGL, extensions are disabled by default
EGLAttrib defaultValue = webGLContext ? EGL_FALSE : EGL_TRUE;
return (attribs.get(EGL_EXTENSIONS_ENABLED_ANGLE, defaultValue) == EGL_TRUE);
}
bool GetBindGeneratesResource(const egl::AttributeMap &attribs)
{
return (attribs.get(EGL_CONTEXT_BIND_GENERATES_RESOURCE_CHROMIUM, EGL_TRUE) == EGL_TRUE);
}
bool GetClientArraysEnabled(const egl::AttributeMap &attribs)
{
return (attribs.get(EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE, EGL_TRUE) == EGL_TRUE);
}
bool GetRobustResourceInit(const egl::AttributeMap &attribs)
{
return (attribs.get(EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE, EGL_FALSE) == EGL_TRUE);
}
std::string GetObjectLabelFromPointer(GLsizei length, const GLchar *label)
{
std::string labelName;
if (label != nullptr)
{
size_t labelLength = length < 0 ? strlen(label) : length;
labelName = std::string(label, labelLength);
}
return labelName;
}
void GetObjectLabelBase(const std::string &objectLabel,
GLsizei bufSize,
GLsizei *length,
GLchar *label)
{
size_t writeLength = objectLabel.length();
if (label != nullptr && bufSize > 0)
{
writeLength = std::min(static_cast<size_t>(bufSize) - 1, objectLabel.length());
std::copy(objectLabel.begin(), objectLabel.begin() + writeLength, label);
label[writeLength] = '\0';
}
if (length != nullptr)
{
*length = static_cast<GLsizei>(writeLength);
}
}
// The rest default to false.
constexpr angle::PackedEnumMap<PrimitiveMode, bool, angle::EnumSize<PrimitiveMode>() + 1>
kValidBasicDrawModes = {{
{PrimitiveMode::Points, true},
{PrimitiveMode::Lines, true},
{PrimitiveMode::LineLoop, true},
{PrimitiveMode::LineStrip, true},
{PrimitiveMode::Triangles, true},
{PrimitiveMode::TriangleStrip, true},
{PrimitiveMode::TriangleFan, true},
}};
enum SubjectIndexes : angle::SubjectIndex
{
kTexture0SubjectIndex = 0,
kTextureMaxSubjectIndex = kTexture0SubjectIndex + IMPLEMENTATION_MAX_ACTIVE_TEXTURES,
kImage0SubjectIndex = kTextureMaxSubjectIndex,
kImageMaxSubjectIndex = kImage0SubjectIndex + IMPLEMENTATION_MAX_IMAGE_UNITS,
kUniformBuffer0SubjectIndex = kImageMaxSubjectIndex,
kUniformBufferMaxSubjectIndex =
kUniformBuffer0SubjectIndex + IMPLEMENTATION_MAX_UNIFORM_BUFFER_BINDINGS,
kSampler0SubjectIndex = kUniformBufferMaxSubjectIndex,
kSamplerMaxSubjectIndex = kSampler0SubjectIndex + IMPLEMENTATION_MAX_ACTIVE_TEXTURES,
kVertexArraySubjectIndex = kSamplerMaxSubjectIndex,
kReadFramebufferSubjectIndex,
kDrawFramebufferSubjectIndex
};
} // anonymous namespace
Context::Context(egl::Display *display,
const egl::Config *config,
const Context *shareContext,
TextureManager *shareTextures,
MemoryProgramCache *memoryProgramCache,
const EGLenum clientType,
const egl::AttributeMap &attribs,
const egl::DisplayExtensions &displayExtensions,
const egl::ClientExtensions &clientExtensions)
: mState(reinterpret_cast<ContextID>(this),
shareContext ? &shareContext->mState : nullptr,
shareTextures,
&mOverlay,
clientType,
GetClientVersion(display, attribs),
GetDebug(attribs),
GetBindGeneratesResource(attribs),
GetClientArraysEnabled(attribs),
GetRobustResourceInit(attribs),
memoryProgramCache != nullptr),
mShared(shareContext != nullptr),
mSkipValidation(GetNoError(attribs)),
mDisplayTextureShareGroup(shareTextures != nullptr),
mErrors(this),
mImplementation(display->getImplementation()
->createContext(mState, &mErrors, config, shareContext, attribs)),
mLabel(nullptr),
mCompiler(),
mConfig(config),
mHasBeenCurrent(false),
mContextLost(false),
mResetStatus(GraphicsResetStatus::NoError),
mContextLostForced(false),
mResetStrategy(GetResetStrategy(attribs)),
mRobustAccess(GetRobustAccess(attribs)),
mSurfacelessSupported(displayExtensions.surfacelessContext),
mExplicitContextAvailable(clientExtensions.explicitContext),
mCurrentDrawSurface(static_cast<egl::Surface *>(EGL_NO_SURFACE)),
mCurrentReadSurface(static_cast<egl::Surface *>(EGL_NO_SURFACE)),
mDisplay(static_cast<egl::Display *>(EGL_NO_DISPLAY)),
mWebGLContext(GetWebGLContext(attribs)),
mBufferAccessValidationEnabled(false),
mExtensionsEnabled(GetExtensionsEnabled(attribs, mWebGLContext)),
mMemoryProgramCache(memoryProgramCache),
mVertexArrayObserverBinding(this, kVertexArraySubjectIndex),
mDrawFramebufferObserverBinding(this, kDrawFramebufferSubjectIndex),
mReadFramebufferObserverBinding(this, kReadFramebufferSubjectIndex),
mScratchBuffer(1000u),
mZeroFilledBuffer(1000u),
mThreadPool(nullptr),
mFrameCapture(new angle::FrameCapture),
mOverlay(mImplementation.get())
{
for (angle::SubjectIndex uboIndex = kUniformBuffer0SubjectIndex;
uboIndex < kUniformBufferMaxSubjectIndex; ++uboIndex)
{
mUniformBufferObserverBindings.emplace_back(this, uboIndex);
}
for (angle::SubjectIndex samplerIndex = kSampler0SubjectIndex;
samplerIndex < kSamplerMaxSubjectIndex; ++samplerIndex)
{
mSamplerObserverBindings.emplace_back(this, samplerIndex);
}
for (angle::SubjectIndex imageIndex = kImage0SubjectIndex; imageIndex < kImageMaxSubjectIndex;
++imageIndex)
{
mImageObserverBindings.emplace_back(this, imageIndex);
}
}
void Context::initialize()
{
mImplementation->setMemoryProgramCache(mMemoryProgramCache);
initCaps();
if (mDisplay->getFrontendFeatures().syncFramebufferBindingsOnTexImage.enabled)
{
mTexImageDirtyBits.set(State::DIRTY_BIT_READ_FRAMEBUFFER_BINDING);
mTexImageDirtyBits.set(State::DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING);
}
mState.initialize(this);
mFenceNVHandleAllocator.setBaseHandle(0);
// [OpenGL ES 2.0.24] section 3.7 page 83:
// In the initial state, TEXTURE_2D and TEXTURE_CUBE_MAP have two-dimensional
// 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(mImplementation.get(), {0}, TextureType::_2D);
mZeroTextures[TextureType::_2D].set(this, zeroTexture2D);
Texture *zeroTextureCube = new Texture(mImplementation.get(), {0}, TextureType::CubeMap);
mZeroTextures[TextureType::CubeMap].set(this, zeroTextureCube);
if (getClientVersion() >= Version(3, 0) || mSupportedExtensions.texture3DOES)
{
Texture *zeroTexture3D = new Texture(mImplementation.get(), {0}, TextureType::_3D);
mZeroTextures[TextureType::_3D].set(this, zeroTexture3D);
}
if (getClientVersion() >= Version(3, 0))
{
Texture *zeroTexture2DArray =
new Texture(mImplementation.get(), {0}, TextureType::_2DArray);
mZeroTextures[TextureType::_2DArray].set(this, zeroTexture2DArray);
}
if (getClientVersion() >= Version(3, 1) || mSupportedExtensions.textureMultisample)
{
Texture *zeroTexture2DMultisample =
new Texture(mImplementation.get(), {0}, TextureType::_2DMultisample);
mZeroTextures[TextureType::_2DMultisample].set(this, zeroTexture2DMultisample);
}
if (getClientVersion() >= Version(3, 1))
{
Texture *zeroTexture2DMultisampleArray =
new Texture(mImplementation.get(), {0}, TextureType::_2DMultisampleArray);
mZeroTextures[TextureType::_2DMultisampleArray].set(this, zeroTexture2DMultisampleArray);
for (int i = 0; i < mState.mCaps.maxAtomicCounterBufferBindings; i++)
{
bindBufferRange(BufferBinding::AtomicCounter, i, {0}, 0, 0);
}
for (int i = 0; i < mState.mCaps.maxShaderStorageBufferBindings; i++)
{
bindBufferRange(BufferBinding::ShaderStorage, i, {0}, 0, 0);
}
}
if (mSupportedExtensions.textureRectangle)
{
Texture *zeroTextureRectangle =
new Texture(mImplementation.get(), {0}, TextureType::Rectangle);
mZeroTextures[TextureType::Rectangle].set(this, zeroTextureRectangle);
}
if (mSupportedExtensions.eglImageExternal || mSupportedExtensions.eglStreamConsumerExternal)
{
Texture *zeroTextureExternal =
new Texture(mImplementation.get(), {0}, TextureType::External);
mZeroTextures[TextureType::External].set(this, zeroTextureExternal);
}
mState.initializeZeroTextures(this, mZeroTextures);
bindVertexArray({0});
if (getClientVersion() >= Version(3, 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
bindTransformFeedback(GL_TRANSFORM_FEEDBACK, {0});
}
for (auto type : angle::AllEnums<BufferBinding>())
{
bindBuffer(type, {0});
}
bindRenderbuffer(GL_RENDERBUFFER, {0});
for (int i = 0; i < mState.mCaps.maxUniformBufferBindings; i++)
{
bindBufferRange(BufferBinding::Uniform, i, {0}, 0, -1);
}
// Initialize GLES1 renderer if appropriate.
if (getClientVersion() < Version(2, 0))
{
mGLES1Renderer.reset(new GLES1Renderer());
}
// Initialize dirty bit masks
mAllDirtyBits.set();
mDrawDirtyObjects.set(State::DIRTY_OBJECT_DRAW_FRAMEBUFFER);
mDrawDirtyObjects.set(State::DIRTY_OBJECT_VERTEX_ARRAY);
mDrawDirtyObjects.set(State::DIRTY_OBJECT_TEXTURES);
mDrawDirtyObjects.set(State::DIRTY_OBJECT_PROGRAM);
mDrawDirtyObjects.set(State::DIRTY_OBJECT_SAMPLERS);
mDrawDirtyObjects.set(State::DIRTY_OBJECT_IMAGES);
mPathOperationDirtyObjects.set(State::DIRTY_OBJECT_DRAW_FRAMEBUFFER);
mPathOperationDirtyObjects.set(State::DIRTY_OBJECT_VERTEX_ARRAY);
mPathOperationDirtyObjects.set(State::DIRTY_OBJECT_TEXTURES);
mPathOperationDirtyObjects.set(State::DIRTY_OBJECT_SAMPLERS);
mTexImageDirtyBits.set(State::DIRTY_BIT_UNPACK_STATE);
mTexImageDirtyBits.set(State::DIRTY_BIT_UNPACK_BUFFER_BINDING);
// No dirty objects.
// Readpixels uses the pack state and read FBO
mReadPixelsDirtyBits.set(State::DIRTY_BIT_PACK_STATE);
mReadPixelsDirtyBits.set(State::DIRTY_BIT_PACK_BUFFER_BINDING);
mReadPixelsDirtyBits.set(State::DIRTY_BIT_READ_FRAMEBUFFER_BINDING);
mReadPixelsDirtyObjects.set(State::DIRTY_OBJECT_READ_FRAMEBUFFER);
mClearDirtyBits.set(State::DIRTY_BIT_RASTERIZER_DISCARD_ENABLED);
mClearDirtyBits.set(State::DIRTY_BIT_SCISSOR_TEST_ENABLED);
mClearDirtyBits.set(State::DIRTY_BIT_SCISSOR);
mClearDirtyBits.set(State::DIRTY_BIT_VIEWPORT);
mClearDirtyBits.set(State::DIRTY_BIT_CLEAR_COLOR);
mClearDirtyBits.set(State::DIRTY_BIT_CLEAR_DEPTH);
mClearDirtyBits.set(State::DIRTY_BIT_CLEAR_STENCIL);
mClearDirtyBits.set(State::DIRTY_BIT_COLOR_MASK);
mClearDirtyBits.set(State::DIRTY_BIT_DEPTH_MASK);
mClearDirtyBits.set(State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT);
mClearDirtyBits.set(State::DIRTY_BIT_STENCIL_WRITEMASK_BACK);
mClearDirtyBits.set(State::DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING);
// We sync the draw Framebuffer manually in prepareForClear to allow the clear calls to do
// more custom handling for robust resource init.
mBlitDirtyBits.set(State::DIRTY_BIT_SCISSOR_TEST_ENABLED);
mBlitDirtyBits.set(State::DIRTY_BIT_SCISSOR);
mBlitDirtyBits.set(State::DIRTY_BIT_FRAMEBUFFER_SRGB);
mBlitDirtyBits.set(State::DIRTY_BIT_READ_FRAMEBUFFER_BINDING);
mBlitDirtyBits.set(State::DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING);
mBlitDirtyObjects.set(State::DIRTY_OBJECT_READ_FRAMEBUFFER);
mBlitDirtyObjects.set(State::DIRTY_OBJECT_DRAW_FRAMEBUFFER);
mComputeDirtyBits.set(State::DIRTY_BIT_SHADER_STORAGE_BUFFER_BINDING);
mComputeDirtyBits.set(State::DIRTY_BIT_UNIFORM_BUFFER_BINDINGS);
mComputeDirtyBits.set(State::DIRTY_BIT_ATOMIC_COUNTER_BUFFER_BINDING);
mComputeDirtyBits.set(State::DIRTY_BIT_PROGRAM_BINDING);
mComputeDirtyBits.set(State::DIRTY_BIT_PROGRAM_EXECUTABLE);
mComputeDirtyBits.set(State::DIRTY_BIT_TEXTURE_BINDINGS);
mComputeDirtyBits.set(State::DIRTY_BIT_SAMPLER_BINDINGS);
mComputeDirtyBits.set(State::DIRTY_BIT_IMAGE_BINDINGS);
mComputeDirtyBits.set(State::DIRTY_BIT_DISPATCH_INDIRECT_BUFFER_BINDING);
mComputeDirtyObjects.set(State::DIRTY_OBJECT_TEXTURES);
mComputeDirtyObjects.set(State::DIRTY_OBJECT_PROGRAM);
mComputeDirtyObjects.set(State::DIRTY_OBJECT_IMAGES);
mComputeDirtyObjects.set(State::DIRTY_OBJECT_SAMPLERS);
mCopyImageDirtyBits.set(State::DIRTY_BIT_READ_FRAMEBUFFER_BINDING);
mCopyImageDirtyObjects.set(State::DIRTY_OBJECT_READ_FRAMEBUFFER);
ANGLE_CONTEXT_TRY(mImplementation->initialize());
// Initialize overlay after implementation is initialized.
ANGLE_CONTEXT_TRY(mOverlay.init(this));
}
egl::Error Context::onDestroy(const egl::Display *display)
{
// Dump frame capture if enabled.
mFrameCapture->onEndFrame(this);
if (mGLES1Renderer)
{
mGLES1Renderer->onDestroy(this, &mState);
}
ANGLE_TRY(unMakeCurrent(display));
for (auto fence : mFenceNVMap)
{
SafeDelete(fence.second);
}
mFenceNVMap.clear();
for (auto query : mQueryMap)
{
if (query.second != nullptr)
{
query.second->release(this);
}
}
mQueryMap.clear();
for (auto vertexArray : mVertexArrayMap)
{
if (vertexArray.second)
{
vertexArray.second->onDestroy(this);
}
}
mVertexArrayMap.clear();
for (auto transformFeedback : mTransformFeedbackMap)
{
if (transformFeedback.second != nullptr)
{
transformFeedback.second->release(this);
}
}
mTransformFeedbackMap.clear();
for (BindingPointer<Texture> &zeroTexture : mZeroTextures)
{
if (zeroTexture.get() != nullptr)
{
zeroTexture.set(this, nullptr);
}
}
releaseShaderCompiler();
mState.reset(this);
mState.mBufferManager->release(this);
mState.mShaderProgramManager->release(this);
mState.mTextureManager->release(this);
mState.mRenderbufferManager->release(this);
mState.mSamplerManager->release(this);
mState.mSyncManager->release(this);
mState.mPathManager->release(this);
mState.mFramebufferManager->release(this);
mState.mProgramPipelineManager->release(this);
mState.mMemoryObjectManager->release(this);
mState.mSemaphoreManager->release(this);
mThreadPool.reset();
mImplementation->onDestroy(this);
mOverlay.destroy(this);
return egl::NoError();
}
Context::~Context() {}
void Context::setLabel(EGLLabelKHR label)
{
mLabel = label;
}
EGLLabelKHR Context::getLabel() const
{
return mLabel;
}
egl::Error Context::makeCurrent(egl::Display *display,
egl::Surface *drawSurface,
egl::Surface *readSurface)
{
mDisplay = display;
if (!mHasBeenCurrent)
{
initialize();
initRendererString();
initVersionStrings();
initExtensionStrings();
int width = 0;
int height = 0;
if (drawSurface != nullptr)
{
width = drawSurface->getWidth();
height = drawSurface->getHeight();
}
mState.setViewportParams(0, 0, width, height);
mState.setScissorParams(0, 0, width, height);
mHasBeenCurrent = true;
}
// TODO(jmadill): Rework this when we support ContextImpl
mState.setAllDirtyBits();
mState.setAllDirtyObjects();
ANGLE_TRY(setDefaultFramebuffer(drawSurface, readSurface));
// Notify the renderer of a context switch.
angle::Result implResult = mImplementation->onMakeCurrent(this);
// If the implementation fails onMakeCurrent, unset the default framebuffer.
if (implResult != angle::Result::Continue)
{
ANGLE_TRY(unsetDefaultFramebuffer());
return angle::ResultToEGL(implResult);
}
return egl::NoError();
}
egl::Error Context::unMakeCurrent(const egl::Display *display)
{
ANGLE_TRY(unsetDefaultFramebuffer());
return angle::ResultToEGL(mImplementation->onUnMakeCurrent(this));
}
BufferID Context::createBuffer()
{
return mState.mBufferManager->createBuffer();
}
GLuint Context::createProgram()
{
return mState.mShaderProgramManager->createProgram(mImplementation.get()).value;
}
GLuint Context::createShader(ShaderType type)
{
return mState.mShaderProgramManager
->createShader(mImplementation.get(), mState.mLimitations, type)
.value;
}
TextureID Context::createTexture()
{
return mState.mTextureManager->createTexture();
}
RenderbufferID Context::createRenderbuffer()
{
return mState.mRenderbufferManager->createRenderbuffer();
}
void Context::tryGenPaths(GLsizei range, PathID *createdOut)
{
ANGLE_CONTEXT_TRY(mState.mPathManager->createPaths(this, range, createdOut));
}
GLuint Context::genPaths(GLsizei range)
{
PathID created = {0};
tryGenPaths(range, &created);
return created.value;
}
// Returns an unused framebuffer name
FramebufferID Context::createFramebuffer()
{
return mState.mFramebufferManager->createFramebuffer();
}
void Context::genFencesNV(GLsizei n, FenceNVID *fences)
{
for (int i = 0; i < n; i++)
{
GLuint handle = mFenceNVHandleAllocator.allocate();
mFenceNVMap.assign({handle}, new FenceNV(mImplementation->createFenceNV()));
fences[i] = {handle};
}
}
ProgramPipelineID Context::createProgramPipeline()
{
return mState.mProgramPipelineManager->createProgramPipeline();
}
GLuint Context::createShaderProgramv(ShaderType type, GLsizei count, const GLchar *const *strings)
{
UNIMPLEMENTED();
return 0u;
}
MemoryObjectID Context::createMemoryObject()
{
return mState.mMemoryObjectManager->createMemoryObject(mImplementation.get());
}
SemaphoreID Context::createSemaphore()
{
return mState.mSemaphoreManager->createSemaphore(mImplementation.get());
}
void Context::deleteBuffer(BufferID bufferName)
{
Buffer *buffer = mState.mBufferManager->getBuffer(bufferName);
if (buffer)
{
detachBuffer(buffer);
}
mState.mBufferManager->deleteObject(this, bufferName);
}
void Context::deleteShader(ShaderProgramID shader)
{
mState.mShaderProgramManager->deleteShader(this, shader);
}
void Context::deleteProgram(ShaderProgramID program)
{
mState.mShaderProgramManager->deleteProgram(this, program);
}
void Context::deleteTexture(TextureID texture)
{
if (mState.mTextureManager->getTexture(texture))
{
detachTexture(texture);
}
mState.mTextureManager->deleteObject(this, texture);
}
void Context::deleteRenderbuffer(RenderbufferID renderbuffer)
{
if (mState.mRenderbufferManager->getRenderbuffer(renderbuffer))
{
detachRenderbuffer(renderbuffer);
}
mState.mRenderbufferManager->deleteObject(this, renderbuffer);
}
void Context::deleteSync(GLsync sync)
{
// 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.
mState.mSyncManager->deleteObject(this, static_cast<GLuint>(reinterpret_cast<uintptr_t>(sync)));
}
void Context::deleteProgramPipeline(ProgramPipelineID pipeline)
{
if (mState.mProgramPipelineManager->getProgramPipeline(pipeline))
{
detachProgramPipeline(pipeline);
}
mState.mProgramPipelineManager->deleteObject(this, pipeline);
}
void Context::deleteMemoryObject(MemoryObjectID memoryObject)
{
mState.mMemoryObjectManager->deleteMemoryObject(this, memoryObject);
}
void Context::deleteSemaphore(SemaphoreID semaphore)
{
mState.mSemaphoreManager->deleteSemaphore(this, semaphore);
}
void Context::deletePaths(PathID first, GLsizei range)
{
mState.mPathManager->deletePaths(first, range);
}
GLboolean Context::isPath(PathID path)
{
const auto *pathObj = mState.mPathManager->getPath(path);
if (pathObj == nullptr)
return false;
return pathObj->hasPathData();
}
bool Context::isPathGenerated(PathID path) const
{
return mState.mPathManager->hasPath(path);
}
void Context::pathCommands(PathID path,
GLsizei numCommands,
const GLubyte *commands,
GLsizei numCoords,
GLenum coordType,
const void *coords)
{
auto *pathObject = mState.mPathManager->getPath(path);
ANGLE_CONTEXT_TRY(pathObject->setCommands(numCommands, commands, numCoords, coordType, coords));
}
void Context::pathParameterf(PathID path, GLenum pname, GLfloat value)
{
Path *pathObj = mState.mPathManager->getPath(path);
switch (pname)
{
case GL_PATH_STROKE_WIDTH_CHROMIUM:
pathObj->setStrokeWidth(value);
break;
case GL_PATH_END_CAPS_CHROMIUM:
pathObj->setEndCaps(static_cast<GLenum>(value));
break;
case GL_PATH_JOIN_STYLE_CHROMIUM:
pathObj->setJoinStyle(static_cast<GLenum>(value));
break;
case GL_PATH_MITER_LIMIT_CHROMIUM:
pathObj->setMiterLimit(value);
break;
case GL_PATH_STROKE_BOUND_CHROMIUM:
pathObj->setStrokeBound(value);
break;
default:
UNREACHABLE();
break;
}
}
void Context::pathParameteri(PathID path, GLenum pname, GLint value)
{
// TODO(jmadill): Should use proper clamping/casting.
pathParameterf(path, pname, static_cast<GLfloat>(value));
}
void Context::getPathParameterfv(PathID path, GLenum pname, GLfloat *value)
{
const Path *pathObj = mState.mPathManager->getPath(path);
switch (pname)
{
case GL_PATH_STROKE_WIDTH_CHROMIUM:
*value = pathObj->getStrokeWidth();
break;
case GL_PATH_END_CAPS_CHROMIUM:
*value = static_cast<GLfloat>(pathObj->getEndCaps());
break;
case GL_PATH_JOIN_STYLE_CHROMIUM:
*value = static_cast<GLfloat>(pathObj->getJoinStyle());
break;
case GL_PATH_MITER_LIMIT_CHROMIUM:
*value = pathObj->getMiterLimit();
break;
case GL_PATH_STROKE_BOUND_CHROMIUM:
*value = pathObj->getStrokeBound();
break;
default:
UNREACHABLE();
break;
}
}
void Context::getPathParameteriv(PathID path, GLenum pname, GLint *value)
{
GLfloat val = 0.0f;
getPathParameterfv(path, pname, value != nullptr ? &val : nullptr);
if (value)
*value = static_cast<GLint>(val);
}
void Context::pathStencilFunc(GLenum func, GLint ref, GLuint mask)
{
mState.setPathStencilFunc(func, ref, mask);
}
// GL_CHROMIUM_lose_context
void Context::loseContext(GraphicsResetStatus current, GraphicsResetStatus other)
{
// TODO(geofflang): mark the rest of the share group lost. Requires access to the entire share
// group from a context. http://anglebug.com/3379
markContextLost(current);
}
void Context::deleteFramebuffer(FramebufferID framebuffer)
{
if (mState.mFramebufferManager->getFramebuffer(framebuffer))
{
detachFramebuffer(framebuffer);
}
mState.mFramebufferManager->deleteObject(this, framebuffer);
}
void Context::deleteFencesNV(GLsizei n, const FenceNVID *fences)
{
for (int i = 0; i < n; i++)
{
FenceNVID fence = fences[i];
FenceNV *fenceObject = nullptr;
if (mFenceNVMap.erase(fence, &fenceObject))
{
mFenceNVHandleAllocator.release(fence.value);
delete fenceObject;
}
}
}
Buffer *Context::getBuffer(BufferID handle) const
{
return mState.mBufferManager->getBuffer(handle);
}
Renderbuffer *Context::getRenderbuffer(RenderbufferID handle) const
{
return mState.mRenderbufferManager->getRenderbuffer(handle);
}
Sync *Context::getSync(GLsync handle) const
{
return mState.mSyncManager->getSync(static_cast<GLuint>(reinterpret_cast<uintptr_t>(handle)));
}
VertexArray *Context::getVertexArray(VertexArrayID handle) const
{
return mVertexArrayMap.query(handle);
}
Sampler *Context::getSampler(SamplerID handle) const
{
return mState.mSamplerManager->getSampler(handle);
}
TransformFeedback *Context::getTransformFeedback(TransformFeedbackID handle) const
{
return mTransformFeedbackMap.query(handle);
}
ProgramPipeline *Context::getProgramPipeline(ProgramPipelineID handle) const
{
return mState.mProgramPipelineManager->getProgramPipeline(handle);
}
gl::LabeledObject *Context::getLabeledObject(GLenum identifier, GLuint name) const
{
switch (identifier)
{
case GL_BUFFER:
return getBuffer({name});
case GL_SHADER:
return getShader({name});
case GL_PROGRAM:
return getProgramNoResolveLink({name});
case GL_VERTEX_ARRAY:
return getVertexArray({name});
case GL_QUERY:
return getQuery({name});
case GL_TRANSFORM_FEEDBACK:
return getTransformFeedback({name});
case GL_SAMPLER:
return getSampler({name});
case GL_TEXTURE:
return getTexture({name});
case GL_RENDERBUFFER:
return getRenderbuffer({name});
case GL_FRAMEBUFFER:
return getFramebuffer({name});
default:
UNREACHABLE();
return nullptr;
}
}
gl::LabeledObject *Context::getLabeledObjectFromPtr(const void *ptr) const
{
return getSync(reinterpret_cast<GLsync>(const_cast<void *>(ptr)));
}
void Context::objectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
{
gl::LabeledObject *object = getLabeledObject(identifier, name);
ASSERT(object != nullptr);
std::string labelName = GetObjectLabelFromPointer(length, label);
object->setLabel(this, labelName);
// TODO(jmadill): Determine if the object is dirty based on 'name'. Conservatively assume the
// specified object is active until we do this.
mState.setObjectDirty(identifier);
}
void Context::objectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
{
gl::LabeledObject *object = getLabeledObjectFromPtr(ptr);
ASSERT(object != nullptr);
std::string labelName = GetObjectLabelFromPointer(length, label);
object->setLabel(this, labelName);
}
void Context::getObjectLabel(GLenum identifier,
GLuint name,
GLsizei bufSize,
GLsizei *length,
GLchar *label)
{
gl::LabeledObject *object = getLabeledObject(identifier, name);
ASSERT(object != nullptr);
const std::string &objectLabel = object->getLabel();
GetObjectLabelBase(objectLabel, bufSize, length, label);
}
void Context::getObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
{
gl::LabeledObject *object = getLabeledObjectFromPtr(ptr);
ASSERT(object != nullptr);
const std::string &objectLabel = object->getLabel();
GetObjectLabelBase(objectLabel, bufSize, length, label);
}
GLboolean Context::isSampler(SamplerID samplerName)
{
return mState.mSamplerManager->isSampler(samplerName);
}
void Context::bindTexture(TextureType target, TextureID handle)
{
Texture *texture = nullptr;
if (handle.value == 0)
{
texture = mZeroTextures[target].get();
}
else
{
texture =
mState.mTextureManager->checkTextureAllocation(mImplementation.get(), handle, target);
}
ASSERT(texture);
mState.setSamplerTexture(this, target, texture);
mStateCache.onActiveTextureChange(this);
}
void Context::bindReadFramebuffer(FramebufferID framebufferHandle)
{
Framebuffer *framebuffer = mState.mFramebufferManager->checkFramebufferAllocation(
mImplementation.get(), mState.mCaps, framebufferHandle);
mState.setReadFramebufferBinding(framebuffer);
mReadFramebufferObserverBinding.bind(framebuffer);
}
void Context::bindDrawFramebuffer(FramebufferID framebufferHandle)
{
Framebuffer *framebuffer = mState.mFramebufferManager->checkFramebufferAllocation(
mImplementation.get(), mState.mCaps, framebufferHandle);
mState.setDrawFramebufferBinding(framebuffer);
mDrawFramebufferObserverBinding.bind(framebuffer);
mStateCache.onDrawFramebufferChange(this);
}
void Context::bindVertexArray(VertexArrayID vertexArrayHandle)
{
VertexArray *vertexArray = checkVertexArrayAllocation(vertexArrayHandle);
mState.setVertexArrayBinding(this, vertexArray);
mVertexArrayObserverBinding.bind(vertexArray);
mStateCache.onVertexArrayBindingChange(this);
}
void Context::bindVertexBuffer(GLuint bindingIndex,
BufferID bufferHandle,
GLintptr offset,
GLsizei stride)
{
Buffer *buffer =
mState.mBufferManager->checkBufferAllocation(mImplementation.get(), bufferHandle);
mState.bindVertexBuffer(this, bindingIndex, buffer, offset, stride);
mStateCache.onVertexArrayStateChange(this);
}
void Context::bindSampler(GLuint textureUnit, SamplerID samplerHandle)
{
ASSERT(textureUnit < static_cast<GLuint>(mState.mCaps.maxCombinedTextureImageUnits));
Sampler *sampler =
mState.mSamplerManager->checkSamplerAllocation(mImplementation.get(), samplerHandle);
mState.setSamplerBinding(this, textureUnit, sampler);
mSamplerObserverBindings[textureUnit].bind(sampler);
mStateCache.onActiveTextureChange(this);
}
void Context::bindImageTexture(GLuint unit,
TextureID texture,
GLint level,
GLboolean layered,
GLint layer,
GLenum access,
GLenum format)
{
Texture *tex = mState.mTextureManager->getTexture(texture);
mState.setImageUnit(this, unit, tex, level, layered, layer, access, format);
mImageObserverBindings[unit].bind(tex);
}
void Context::useProgram(ShaderProgramID program)
{
ANGLE_CONTEXT_TRY(mState.setProgram(this, getProgramResolveLink(program)));
mStateCache.onProgramExecutableChange(this);
}
void Context::useProgramStages(ProgramPipelineID pipeline,
GLbitfield stages,
ShaderProgramID program)
{
UNIMPLEMENTED();
}
void Context::bindTransformFeedback(GLenum target, TransformFeedbackID transformFeedbackHandle)
{
ASSERT(target == GL_TRANSFORM_FEEDBACK);
TransformFeedback *transformFeedback =
checkTransformFeedbackAllocation(transformFeedbackHandle);
mState.setTransformFeedbackBinding(this, transformFeedback);
}
void Context::bindProgramPipeline(ProgramPipelineID pipelineHandle)
{
ProgramPipeline *pipeline = mState.mProgramPipelineManager->checkProgramPipelineAllocation(
mImplementation.get(), pipelineHandle);
mState.setProgramPipelineBinding(this, pipeline);
}
void Context::beginQuery(QueryType target, QueryID query)
{
Query *queryObject = getQuery(query, true, target);
ASSERT(queryObject);
// begin query
ANGLE_CONTEXT_TRY(queryObject->begin(this));
// set query as active for specified target only if begin succeeded
mState.setActiveQuery(this, target, queryObject);
mStateCache.onQueryChange(this);
}
void Context::endQuery(QueryType target)
{
Query *queryObject = mState.getActiveQuery(target);
ASSERT(queryObject);
// Intentionally don't call try here. We don't want an early return.
(void)(queryObject->end(this));
// Always unbind the query, even if there was an error. This may delete the query object.
mState.setActiveQuery(this, target, nullptr);
mStateCache.onQueryChange(this);
}
void Context::queryCounter(QueryID id, QueryType target)
{
ASSERT(target == QueryType::Timestamp);
Query *queryObject = getQuery(id, true, target);
ASSERT(queryObject);
ANGLE_CONTEXT_TRY(queryObject->queryCounter(this));
}
void Context::getQueryiv(QueryType target, GLenum pname, GLint *params)
{
switch (pname)
{
case GL_CURRENT_QUERY_EXT:
params[0] = mState.getActiveQueryId(target).value;
break;
case GL_QUERY_COUNTER_BITS_EXT:
switch (target)
{
case QueryType::TimeElapsed:
params[0] = getExtensions().queryCounterBitsTimeElapsed;
break;
case QueryType::Timestamp:
params[0] = getExtensions().queryCounterBitsTimestamp;
break;
default:
UNREACHABLE();
params[0] = 0;
break;
}
break;
default:
UNREACHABLE();
return;
}
}
void Context::getQueryivRobust(QueryType target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
getQueryiv(target, pname, params);
}
void Context::getUnsignedBytev(GLenum pname, GLubyte *data)
{
UNIMPLEMENTED();
}
void Context::getUnsignedBytei_v(GLenum target, GLuint index, GLubyte *data)
{
UNIMPLEMENTED();
}
void Context::getQueryObjectiv(QueryID id, GLenum pname, GLint *params)
{
ANGLE_CONTEXT_TRY(GetQueryObjectParameter(this, getQuery(id), pname, params));
}
void Context::getQueryObjectivRobust(QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
getQueryObjectiv(id, pname, params);
}
void Context::getQueryObjectuiv(QueryID id, GLenum pname, GLuint *params)
{
ANGLE_CONTEXT_TRY(GetQueryObjectParameter(this, getQuery(id), pname, params));
}
void Context::getQueryObjectuivRobust(QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params)
{
getQueryObjectuiv(id, pname, params);
}
void Context::getQueryObjecti64v(QueryID id, GLenum pname, GLint64 *params)
{
ANGLE_CONTEXT_TRY(GetQueryObjectParameter(this, getQuery(id), pname, params));
}
void Context::getQueryObjecti64vRobust(QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint64 *params)
{
getQueryObjecti64v(id, pname, params);
}
void Context::getQueryObjectui64v(QueryID id, GLenum pname, GLuint64 *params)
{
ANGLE_CONTEXT_TRY(GetQueryObjectParameter(this, getQuery(id), pname, params));
}
void Context::getQueryObjectui64vRobust(QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint64 *params)
{
getQueryObjectui64v(id, pname, params);
}
Framebuffer *Context::getFramebuffer(FramebufferID handle) const
{
return mState.mFramebufferManager->getFramebuffer(handle);
}
FenceNV *Context::getFenceNV(FenceNVID handle)
{
return mFenceNVMap.query(handle);
}
Query *Context::getQuery(QueryID handle, bool create, QueryType type)
{
if (!mQueryMap.contains(handle))
{
return nullptr;
}
Query *query = mQueryMap.query(handle);
if (!query && create)
{
ASSERT(type != QueryType::InvalidEnum);
query = new Query(mImplementation->createQuery(type), handle);
query->addRef();
mQueryMap.assign(handle, query);
}
return query;
}
Query *Context::getQuery(QueryID handle) const
{
return mQueryMap.query(handle);
}
Texture *Context::getTextureByType(TextureType type) const
{
ASSERT(ValidTextureTarget(this, type) || ValidTextureExternalTarget(this, type));
return mState.getTargetTexture(type);
}
Texture *Context::getTextureByTarget(TextureTarget target) const
{
return getTextureByType(TextureTargetToType(target));
}
Texture *Context::getSamplerTexture(unsigned int sampler, TextureType type) const
{
return mState.getSamplerTexture(sampler, type);
}
Compiler *Context::getCompiler() const
{
if (mCompiler.get() == nullptr)
{
mCompiler.set(this, new Compiler(mImplementation.get(), mState));
}
return mCompiler.get();
}
void Context::getBooleanvImpl(GLenum pname, GLboolean *params)
{
switch (pname)
{
case GL_SHADER_COMPILER:
*params = GL_TRUE;
break;
case GL_CONTEXT_ROBUST_ACCESS_EXT:
*params = ConvertToGLBoolean(mRobustAccess);
break;
default:
mState.getBooleanv(pname, params);
break;
}
}
void Context::getFloatvImpl(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] = mState.mCaps.minAliasedLineWidth;
params[1] = mState.mCaps.maxAliasedLineWidth;
break;
case GL_ALIASED_POINT_SIZE_RANGE:
params[0] = mState.mCaps.minAliasedPointSize;
params[1] = mState.mCaps.maxAliasedPointSize;
break;
case GL_SMOOTH_POINT_SIZE_RANGE:
params[0] = mState.mCaps.minSmoothPointSize;
params[1] = mState.mCaps.maxSmoothPointSize;
break;
case GL_SMOOTH_LINE_WIDTH_RANGE:
params[0] = mState.mCaps.minSmoothLineWidth;
params[1] = mState.mCaps.maxSmoothLineWidth;
break;
case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
ASSERT(mState.mExtensions.textureFilterAnisotropic);
*params = mState.mExtensions.maxTextureAnisotropy;
break;
case GL_MAX_TEXTURE_LOD_BIAS:
*params = mState.mCaps.maxLODBias;
break;
case GL_PATH_MODELVIEW_MATRIX_CHROMIUM:
case GL_PATH_PROJECTION_MATRIX_CHROMIUM:
{
// GLES1 emulation: // GL_PATH_(MODELVIEW|PROJECTION)_MATRIX_CHROMIUM collides with the
// GLES1 constants for modelview/projection matrix.
if (getClientVersion() < Version(2, 0))
{
mState.getFloatv(pname, params);
}
else
{
ASSERT(mState.mExtensions.pathRendering);
const GLfloat *m = mState.getPathRenderingMatrix(pname);
memcpy(params, m, 16 * sizeof(GLfloat));
}
}
break;
default:
mState.getFloatv(pname, params);
break;
}
}
void Context::getIntegervImpl(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 = mState.mCaps.maxVertexAttributes;
break;
case GL_MAX_VERTEX_UNIFORM_VECTORS:
*params = mState.mCaps.maxVertexUniformVectors;
break;
case GL_MAX_VERTEX_UNIFORM_COMPONENTS:
*params = mState.mCaps.maxShaderUniformComponents[ShaderType::Vertex];
break;
case GL_MAX_VARYING_VECTORS:
*params = mState.mCaps.maxVaryingVectors;
break;
case GL_MAX_VARYING_COMPONENTS:
*params = mState.mCaps.maxVertexOutputComponents;
break;
case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
*params = mState.mCaps.maxCombinedTextureImageUnits;
break;
case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
*params = mState.mCaps.maxShaderTextureImageUnits[ShaderType::Vertex];
break;
case GL_MAX_TEXTURE_IMAGE_UNITS:
*params = mState.mCaps.maxShaderTextureImageUnits[ShaderType::Fragment];
break;
case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
*params = mState.mCaps.maxFragmentUniformVectors;
break;
case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
*params = mState.mCaps.maxShaderUniformComponents[ShaderType::Fragment];
break;
case GL_MAX_RENDERBUFFER_SIZE:
*params = mState.mCaps.maxRenderbufferSize;
break;
case GL_MAX_COLOR_ATTACHMENTS_EXT:
*params = mState.mCaps.maxColorAttachments;
break;
case GL_MAX_DRAW_BUFFERS_EXT:
*params = mState.mCaps.maxDrawBuffers;
break;
case GL_SUBPIXEL_BITS:
*params = mState.mCaps.subPixelBits;
break;
case GL_MAX_TEXTURE_SIZE:
*params = mState.mCaps.max2DTextureSize;
break;
case GL_MAX_RECTANGLE_TEXTURE_SIZE_ANGLE:
*params = mState.mCaps.maxRectangleTextureSize;
break;
case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
*params = mState.mCaps.maxCubeMapTextureSize;
break;
case GL_MAX_3D_TEXTURE_SIZE:
*params = mState.mCaps.max3DTextureSize;
break;
case GL_MAX_ARRAY_TEXTURE_LAYERS:
*params = mState.mCaps.maxArrayTextureLayers;
break;
case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
*params = mState.mCaps.uniformBufferOffsetAlignment;
break;
case GL_MAX_UNIFORM_BUFFER_BINDINGS:
*params = mState.mCaps.maxUniformBufferBindings;
break;
case GL_MAX_VERTEX_UNIFORM_BLOCKS:
*params = mState.mCaps.maxShaderUniformBlocks[ShaderType::Vertex];
break;
case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
*params = mState.mCaps.maxShaderUniformBlocks[ShaderType::Fragment];
break;
case GL_MAX_COMBINED_UNIFORM_BLOCKS:
*params = mState.mCaps.maxCombinedUniformBlocks;
break;
case GL_MAX_VERTEX_OUTPUT_COMPONENTS:
*params = mState.mCaps.maxVertexOutputComponents;
break;
case GL_MAX_FRAGMENT_INPUT_COMPONENTS:
*params = mState.mCaps.maxFragmentInputComponents;
break;
case GL_MIN_PROGRAM_TEXEL_OFFSET:
*params = mState.mCaps.minProgramTexelOffset;
break;
case GL_MAX_PROGRAM_TEXEL_OFFSET:
*params = mState.mCaps.maxProgramTexelOffset;
break;
case GL_MAJOR_VERSION:
*params = getClientVersion().major;
break;
case GL_MINOR_VERSION:
*params = getClientVersion().minor;
break;
case GL_MAX_ELEMENTS_INDICES:
*params = mState.mCaps.maxElementsIndices;
break;
case GL_MAX_ELEMENTS_VERTICES:
*params = mState.mCaps.maxElementsVertices;
break;
case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
*params = mState.mCaps.maxTransformFeedbackInterleavedComponents;
break;
case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
*params = mState.mCaps.maxTransformFeedbackSeparateAttributes;
break;
case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
*params = mState.mCaps.maxTransformFeedbackSeparateComponents;
break;
case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
*params = static_cast<GLint>(mState.mCaps.compressedTextureFormats.size());
break;
case GL_MAX_SAMPLES_ANGLE:
*params = mState.mCaps.maxSamples;
break;
case GL_MAX_VIEWPORT_DIMS:
{
params[0] = mState.mCaps.maxViewportWidth;
params[1] = mState.mCaps.maxViewportHeight;
}
break;
case GL_COMPRESSED_TEXTURE_FORMATS:
std::copy(mState.mCaps.compressedTextureFormats.begin(),
mState.mCaps.compressedTextureFormats.end(), params);
break;
case GL_RESET_NOTIFICATION_STRATEGY_EXT:
*params = mResetStrategy;
break;
case GL_NUM_SHADER_BINARY_FORMATS:
*params = static_cast<GLint>(mState.mCaps.shaderBinaryFormats.size());
break;
case GL_SHADER_BINARY_FORMATS:
std::copy(mState.mCaps.shaderBinaryFormats.begin(),
mState.mCaps.shaderBinaryFormats.end(), params);
break;
case GL_NUM_PROGRAM_BINARY_FORMATS:
*params = static_cast<GLint>(mState.mCaps.programBinaryFormats.size());
break;
case GL_PROGRAM_BINARY_FORMATS:
std::copy(mState.mCaps.programBinaryFormats.begin(),
mState.mCaps.programBinaryFormats.end(), params);
break;
case GL_NUM_EXTENSIONS:
*params = static_cast<GLint>(mExtensionStrings.size());
break;
// Desktop client flags
case GL_CONTEXT_FLAGS:
ASSERT(getClientType() == EGL_OPENGL_API);
*params = 0;
break;
case GL_CONTEXT_PROFILE_MASK:
ASSERT(getClientType() == EGL_OPENGL_API);
*params = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
break;
// GL_ANGLE_request_extension
case GL_NUM_REQUESTABLE_EXTENSIONS_ANGLE:
*params = static_cast<GLint>(mRequestableExtensionStrings.size());
break;
// GL_KHR_debug
case GL_MAX_DEBUG_MESSAGE_LENGTH:
*params = mState.mExtensions.maxDebugMessageLength;
break;
case GL_MAX_DEBUG_LOGGED_MESSAGES:
*params = mState.mExtensions.maxDebugLoggedMessages;
break;
case GL_MAX_DEBUG_GROUP_STACK_DEPTH:
*params = mState.mExtensions.maxDebugGroupStackDepth;
break;
case GL_MAX_LABEL_LENGTH:
*params = mState.mExtensions.maxLabelLength;
break;
// GL_OVR_multiview2
case GL_MAX_VIEWS_OVR:
*params = mState.mExtensions.maxViews;
break;
// GL_EXT_disjoint_timer_query
case GL_GPU_DISJOINT_EXT:
*params = mImplementation->getGPUDisjoint();
break;
case GL_MAX_FRAMEBUFFER_WIDTH:
*params = mState.mCaps.maxFramebufferWidth;
break;
case GL_MAX_FRAMEBUFFER_HEIGHT:
*params = mState.mCaps.maxFramebufferHeight;
break;
case GL_MAX_FRAMEBUFFER_SAMPLES:
*params = mState.mCaps.maxFramebufferSamples;
break;
case GL_MAX_SAMPLE_MASK_WORDS:
*params = mState.mCaps.maxSampleMaskWords;
break;
case GL_MAX_COLOR_TEXTURE_SAMPLES:
*params = mState.mCaps.maxColorTextureSamples;
break;
case GL_MAX_DEPTH_TEXTURE_SAMPLES:
*params = mState.mCaps.maxDepthTextureSamples;
break;
case GL_MAX_INTEGER_SAMPLES:
*params = mState.mCaps.maxIntegerSamples;
break;
case GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
*params = mState.mCaps.maxVertexAttribRelativeOffset;
break;
case GL_MAX_VERTEX_ATTRIB_BINDINGS:
*params = mState.mCaps.maxVertexAttribBindings;
break;
case GL_MAX_VERTEX_ATTRIB_STRIDE:
*params = mState.mCaps.maxVertexAttribStride;
break;
case GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
*params = mState.mCaps.maxShaderAtomicCounterBuffers[ShaderType::Vertex];
break;
case GL_MAX_VERTEX_ATOMIC_COUNTERS:
*params = mState.mCaps.maxShaderAtomicCounters[ShaderType::Vertex];
break;
case GL_MAX_VERTEX_IMAGE_UNIFORMS:
*params = mState.mCaps.maxShaderImageUniforms[ShaderType::Vertex];
break;
case GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
*params = mState.mCaps.maxShaderStorageBlocks[ShaderType::Vertex];
break;
case GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
*params = mState.mCaps.maxShaderAtomicCounterBuffers[ShaderType::Fragment];
break;
case GL_MAX_FRAGMENT_ATOMIC_COUNTERS:
*params = mState.mCaps.maxShaderAtomicCounters[ShaderType::Fragment];
break;
case GL_MAX_FRAGMENT_IMAGE_UNIFORMS:
*params = mState.mCaps.maxShaderImageUniforms[ShaderType::Fragment];
break;
case GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
*params = mState.mCaps.maxShaderStorageBlocks[ShaderType::Fragment];
break;
case GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
*params = mState.mCaps.minProgramTextureGatherOffset;
break;
case GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
*params = mState.mCaps.maxProgramTextureGatherOffset;
break;
case GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS:
*params = mState.mCaps.maxComputeWorkGroupInvocations;
break;
case GL_MAX_COMPUTE_UNIFORM_BLOCKS:
*params = mState.mCaps.maxShaderUniformBlocks[ShaderType::Compute];
break;
case GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
*params = mState.mCaps.maxShaderTextureImageUnits[ShaderType::Compute];
break;
case GL_MAX_COMPUTE_SHARED_MEMORY_SIZE:
*params = mState.mCaps.maxComputeSharedMemorySize;
break;
case GL_MAX_COMPUTE_UNIFORM_COMPONENTS:
*params = mState.mCaps.maxShaderUniformComponents[ShaderType::Compute];
break;
case GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
*params = mState.mCaps.maxShaderAtomicCounterBuffers[ShaderType::Compute];
break;
case GL_MAX_COMPUTE_ATOMIC_COUNTERS:
*params = mState.mCaps.maxShaderAtomicCounters[ShaderType::Compute];
break;
case GL_MAX_COMPUTE_IMAGE_UNIFORMS:
*params = mState.mCaps.maxShaderImageUniforms[ShaderType::Compute];
break;
case GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS:
*params = static_cast<GLint>(
mState.mCaps.maxCombinedShaderUniformComponents[ShaderType::Compute]);
break;
case GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
*params = mState.mCaps.maxShaderStorageBlocks[ShaderType::Compute];
break;
case GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
*params = mState.mCaps.maxCombinedShaderOutputResources;
break;
case GL_MAX_UNIFORM_LOCATIONS:
*params = mState.mCaps.maxUniformLocations;
break;
case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
*params = mState.mCaps.maxAtomicCounterBufferBindings;
break;
case GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
*params = mState.mCaps.maxAtomicCounterBufferSize;
break;
case GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS:
*params = mState.mCaps.maxCombinedAtomicCounterBuffers;
break;
case GL_MAX_COMBINED_ATOMIC_COUNTERS:
*params = mState.mCaps.maxCombinedAtomicCounters;
break;
case GL_MAX_IMAGE_UNITS:
*params = mState.mCaps.maxImageUnits;
break;
case GL_MAX_COMBINED_IMAGE_UNIFORMS:
*params = mState.mCaps.maxCombinedImageUniforms;
break;
case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
*params = mState.mCaps.maxShaderStorageBufferBindings;
break;
case GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
*params = mState.mCaps.maxCombinedShaderStorageBlocks;
break;
case GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
*params = mState.mCaps.shaderStorageBufferOffsetAlignment;
break;
// GL_EXT_geometry_shader
case GL_MAX_FRAMEBUFFER_LAYERS_EXT:
*params = mState.mCaps.maxFramebufferLayers;
break;
case GL_LAYER_PROVOKING_VERTEX_EXT:
*params = mState.mCaps.layerProvokingVertex;
break;
case GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT:
*params = mState.mCaps.maxShaderUniformComponents[ShaderType::Geometry];
break;
case GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT:
*params = mState.mCaps.maxShaderUniformBlocks[ShaderType::Geometry];
break;
case GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT:
*params = static_cast<GLint>(
mState.mCaps.maxCombinedShaderUniformComponents[ShaderType::Geometry]);
break;
case GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT:
*params = mState.mCaps.maxGeometryInputComponents;
break;
case GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT:
*params = mState.mCaps.maxGeometryOutputComponents;
break;
case GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT:
*params = mState.mCaps.maxGeometryOutputVertices;
break;
case GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT:
*params = mState.mCaps.maxGeometryTotalOutputComponents;
break;
case GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT:
*params = mState.mCaps.maxGeometryShaderInvocations;
break;
case GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT:
*params = mState.mCaps.maxShaderTextureImageUnits[ShaderType::Geometry];
break;
case GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT:
*params = mState.mCaps.maxShaderAtomicCounterBuffers[ShaderType::Geometry];
break;
case GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT:
*params = mState.mCaps.maxShaderAtomicCounters[ShaderType::Geometry];
break;
case GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT:
*params = mState.mCaps.maxShaderImageUniforms[ShaderType::Geometry];
break;
case GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT:
*params = mState.mCaps.maxShaderStorageBlocks[ShaderType::Geometry];
break;
// GLES1 emulation: Caps queries
case GL_MAX_TEXTURE_UNITS:
*params = mState.mCaps.maxMultitextureUnits;
break;
case GL_MAX_MODELVIEW_STACK_DEPTH:
*params = mState.mCaps.maxModelviewMatrixStackDepth;
break;
case GL_MAX_PROJECTION_STACK_DEPTH:
*params = mState.mCaps.maxProjectionMatrixStackDepth;
break;
case GL_MAX_TEXTURE_STACK_DEPTH:
*params = mState.mCaps.maxTextureMatrixStackDepth;
break;
case GL_MAX_LIGHTS:
*params = mState.mCaps.maxLights;
break;
case GL_MAX_CLIP_PLANES:
*params = mState.mCaps.maxClipPlanes;
break;
// GLES1 emulation: Vertex attribute queries
case GL_VERTEX_ARRAY_BUFFER_BINDING:
case GL_NORMAL_ARRAY_BUFFER_BINDING:
case GL_COLOR_ARRAY_BUFFER_BINDING:
case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
getVertexAttribiv(static_cast<GLuint>(vertexArrayIndex(ParamToVertexArrayType(pname))),
GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, params);
break;
case GL_VERTEX_ARRAY_STRIDE:
case GL_NORMAL_ARRAY_STRIDE:
case GL_COLOR_ARRAY_STRIDE:
case GL_POINT_SIZE_ARRAY_STRIDE_OES:
case GL_TEXTURE_COORD_ARRAY_STRIDE:
getVertexAttribiv(static_cast<GLuint>(vertexArrayIndex(ParamToVertexArrayType(pname))),
GL_VERTEX_ATTRIB_ARRAY_STRIDE, params);
break;
case GL_VERTEX_ARRAY_SIZE:
case GL_COLOR_ARRAY_SIZE:
case GL_TEXTURE_COORD_ARRAY_SIZE:
getVertexAttribiv(static_cast<GLuint>(vertexArrayIndex(ParamToVertexArrayType(pname))),
GL_VERTEX_ATTRIB_ARRAY_SIZE, params);
break;
case GL_VERTEX_ARRAY_TYPE:
case GL_COLOR_ARRAY_TYPE:
case GL_NORMAL_ARRAY_TYPE:
case GL_POINT_SIZE_ARRAY_TYPE_OES:
case GL_TEXTURE_COORD_ARRAY_TYPE:
getVertexAttribiv(static_cast<GLuint>(vertexArrayIndex(ParamToVertexArrayType(pname))),
GL_VERTEX_ATTRIB_ARRAY_TYPE, params);
break;
// GL_KHR_parallel_shader_compile
case GL_MAX_SHADER_COMPILER_THREADS_KHR:
*params = mState.getMaxShaderCompilerThreads();
break;
// GL_EXT_blend_func_extended
case GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT:
*params = mState.mExtensions.maxDualSourceDrawBuffers;
break;
default:
ANGLE_CONTEXT_TRY(mState.getIntegerv(this, pname, params));
break;
}
}
void Context::getInteger64vImpl(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 = mState.mCaps.maxElementIndex;
break;
case GL_MAX_UNIFORM_BLOCK_SIZE:
*params = mState.mCaps.maxUniformBlockSize;
break;
case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
*params = mState.mCaps.maxCombinedShaderUniformComponents[ShaderType::Vertex];
break;
case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
*params = mState.mCaps.maxCombinedShaderUniformComponents[ShaderType::Fragment];
break;
case GL_MAX_SERVER_WAIT_TIMEOUT:
*params = mState.mCaps.maxServerWaitTimeout;
break;
// GL_EXT_disjoint_timer_query
case GL_TIMESTAMP_EXT:
*params = mImplementation->getTimestamp();
break;
case GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
*params = mState.mCaps.maxShaderStorageBlockSize;
break;
default:
UNREACHABLE();
break;
}
}
void Context::getPointerv(GLenum pname, void **params)
{
mState.getPointerv(this, pname, params);
}
void Context::getPointervRobustANGLERobust(GLenum pname,
GLsizei bufSize,
GLsizei *length,
void **params)
{
UNIMPLEMENTED();
}
void Context::getIntegeri_v(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.
GLenum nativeType;
unsigned int numParams;
bool queryStatus = getIndexedQueryParameterInfo(target, &nativeType, &numParams);
ASSERT(queryStatus);
if (nativeType == GL_INT)
{
switch (target)
{
case GL_MAX_COMPUTE_WORK_GROUP_COUNT:
ASSERT(index < 3u);
*data = mState.mCaps.maxComputeWorkGroupCount[index];
break;
case GL_MAX_COMPUTE_WORK_GROUP_SIZE:
ASSERT(index < 3u);
*data = mState.mCaps.maxComputeWorkGroupSize[index];
break;
default:
mState.getIntegeri_v(target, index, data);
}
}
else
{
CastIndexedStateValues(this, nativeType, target, index, numParams, data);
}
}
void Context::getIntegeri_vRobust(GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint *data)
{
getIntegeri_v(target, index, data);
}
void Context::getInteger64i_v(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.
GLenum nativeType;
unsigned int numParams;
bool queryStatus = getIndexedQueryParameterInfo(target, &nativeType, &numParams);
ASSERT(queryStatus);
if (nativeType == GL_INT_64_ANGLEX)
{
mState.getInteger64i_v(target, index, data);
}
else
{
CastIndexedStateValues(this, nativeType, target, index, numParams, data);
}
}
void Context::getInteger64i_vRobust(GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint64 *data)
{
getInteger64i_v(target, index, data);
}
void Context::getBooleani_v(GLenum target, GLuint index, GLboolean *data)
{
// Queries about context capabilities and maximums are answered by Context.
// Queries about current GL state values are answered by State.
GLenum nativeType;
unsigned int numParams;
bool queryStatus = getIndexedQueryParameterInfo(target, &nativeType, &numParams);
ASSERT(queryStatus);
if (nativeType == GL_BOOL)
{
mState.getBooleani_v(target, index, data);
}
else
{
CastIndexedStateValues(this, nativeType, target, index, numParams, data);
}
}
void Context::getBooleani_vRobust(GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLboolean *data)
{
getBooleani_v(target, index, data);
}
void Context::getBufferParameteriv(BufferBinding target, GLenum pname, GLint *params)
{
Buffer *buffer = mState.getTargetBuffer(target);
QueryBufferParameteriv(buffer, pname, params);
}
void Context::getBufferParameterivRobust(BufferBinding target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
getBufferParameteriv(target, pname, params);
}
void Context::getFramebufferAttachmentParameteriv(GLenum target,
GLenum attachment,
GLenum pname,
GLint *params)
{
const Framebuffer *framebuffer = mState.getTargetFramebuffer(target);
QueryFramebufferAttachmentParameteriv(this, framebuffer, attachment, pname, params);
}
void Context::getFramebufferAttachmentParameterivRobust(GLenum target,
GLenum attachment,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
getFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
void Context::getRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
Renderbuffer *renderbuffer = mState.getCurrentRenderbuffer();
QueryRenderbufferiv(this, renderbuffer, pname, params);
}
void Context::getRenderbufferParameterivRobust(GLenum target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
getRenderbufferParameteriv(target, pname, params);
}
void Context::texBuffer(GLenum target, GLenum internalformat, BufferID buffer)
{
UNIMPLEMENTED();
}
void Context::texBufferRange(GLenum target,
GLenum internalformat,
BufferID buffer,
GLintptr offset,
GLsizeiptr size)
{
UNIMPLEMENTED();
}
void Context::getTexParameterfv(TextureType target, GLenum pname, GLfloat *params)
{
const Texture *const texture = getTextureByType(target);
QueryTexParameterfv(this, texture, pname, params);
}
void Context::getTexParameterfvRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params)
{
getTexParameterfv(target, pname, params);
}
void Context::getTexParameteriv(TextureType target, GLenum pname, GLint *params)
{
const Texture *const texture = getTextureByType(target);
QueryTexParameteriv(this, texture, pname, params);
}
void Context::getTexParameterIiv(TextureType target, GLenum pname, GLint *params)
{
const Texture *const texture = getTextureByType(target);
QueryTexParameterIiv(this, texture, pname, params);
}
void Context::getTexParameterIuiv(TextureType target, GLenum pname, GLuint *params)
{
const Texture *const texture = getTextureByType(target);
QueryTexParameterIuiv(this, texture, pname, params);
}
void Context::getTexParameterivRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
getTexParameteriv(target, pname, params);
}
void Context::getTexParameterIivRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
UNIMPLEMENTED();
}
void Context::getTexParameterIuivRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params)
{
UNIMPLEMENTED();
}
void Context::getTexLevelParameteriv(TextureTarget target, GLint level, GLenum pname, GLint *params)
{
Texture *texture = getTextureByTarget(target);
QueryTexLevelParameteriv(texture, target, level, pname, params);
}
void Context::getTexLevelParameterivRobust(TextureTarget target,
GLint level,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
UNIMPLEMENTED();
}
void Context::getTexLevelParameterfv(TextureTarget target,
GLint level,
GLenum pname,
GLfloat *params)
{
Texture *texture = getTextureByTarget(target);
QueryTexLevelParameterfv(texture, target, level, pname, params);
}
void Context::getTexLevelParameterfvRobust(TextureTarget target,
GLint level,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params)
{
UNIMPLEMENTED();
}
void Context::texParameterf(TextureType target, GLenum pname, GLfloat param)
{
Texture *const texture = getTextureByType(target);
SetTexParameterf(this, texture, pname, param);
}
void Context::texParameterfv(TextureType target, GLenum pname, const GLfloat *params)
{
Texture *const texture = getTextureByType(target);
SetTexParameterfv(this, texture, pname, params);
}
void Context::texParameterfvRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
const GLfloat *params)
{
texParameterfv(target, pname, params);
}
void Context::texParameteri(TextureType target, GLenum pname, GLint param)
{
Texture *const texture = getTextureByType(target);
SetTexParameteri(this, texture, pname, param);
}
void Context::texParameteriv(TextureType target, GLenum pname, const GLint *params)
{
Texture *const texture = getTextureByType(target);
SetTexParameteriv(this, texture, pname, params);
}
void Context::texParameterIiv(TextureType target, GLenum pname, const GLint *params)
{
Texture *const texture = getTextureByType(target);
SetTexParameterIiv(this, texture, pname, params);
}
void Context::texParameterIuiv(TextureType target, GLenum pname, const GLuint *params)
{
Texture *const texture = getTextureByType(target);
SetTexParameterIuiv(this, texture, pname, params);
}
void Context::texParameterivRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
const GLint *params)
{
texParameteriv(target, pname, params);
}
void Context::texParameterIivRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
const GLint *params)
{
UNIMPLEMENTED();
}
void Context::texParameterIuivRobust(TextureType target,
GLenum pname,
GLsizei bufSize,
const GLuint *params)
{
UNIMPLEMENTED();
}
void Context::drawArraysInstanced(PrimitiveMode mode,
GLint first,
GLsizei count,
GLsizei instanceCount)
{
// No-op if count draws no primitives for given mode
if (noopDrawInstanced(mode, count, instanceCount))
{
return;
}
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(
mImplementation->drawArraysInstanced(this, mode, first, count, instanceCount));
MarkTransformFeedbackBufferUsage(this, count, instanceCount);
MarkShaderStorageBufferUsage(this);
}
void Context::drawElementsInstanced(PrimitiveMode mode,
GLsizei count,
DrawElementsType type,
const void *indices,
GLsizei instances)
{
// No-op if count draws no primitives for given mode
if (noopDrawInstanced(mode, count, instances))
{
return;
}
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(
mImplementation->drawElementsInstanced(this, mode, count, type, indices, instances));
MarkShaderStorageBufferUsage(this);
}
void Context::drawElementsBaseVertex(PrimitiveMode mode,
GLsizei count,
DrawElementsType type,
const void *indices,
GLint basevertex)
{
// No-op if count draws no primitives for given mode
if (noopDraw(mode, count))
{
return;
}
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(
mImplementation->drawElementsBaseVertex(this, mode, count, type, indices, basevertex));
MarkShaderStorageBufferUsage(this);
}
void Context::drawElementsInstancedBaseVertex(PrimitiveMode mode,
GLsizei count,
DrawElementsType type,
const void *indices,
GLsizei instancecount,
GLint basevertex)
{
// No-op if count draws no primitives for given mode
if (noopDrawInstanced(mode, count, instancecount))
{
return;
}
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(mImplementation->drawElementsInstancedBaseVertex(
this, mode, count, type, indices, instancecount, basevertex));
MarkShaderStorageBufferUsage(this);
}
void Context::drawRangeElements(PrimitiveMode mode,
GLuint start,
GLuint end,
GLsizei count,
DrawElementsType type,
const void *indices)
{
// No-op if count draws no primitives for given mode
if (noopDraw(mode, count))
{
return;
}
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(
mImplementation->drawRangeElements(this, mode, start, end, count, type, indices));
MarkShaderStorageBufferUsage(this);
}
void Context::drawRangeElementsBaseVertex(PrimitiveMode mode,
GLuint start,
GLuint end,
GLsizei count,
DrawElementsType type,
const void *indices,
GLint basevertex)
{
// No-op if count draws no primitives for given mode
if (noopDraw(mode, count))
{
return;
}
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(mImplementation->drawRangeElementsBaseVertex(this, mode, start, end, count,
type, indices, basevertex));
MarkShaderStorageBufferUsage(this);
}
void Context::drawArraysIndirect(PrimitiveMode mode, const void *indirect)
{
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(mImplementation->drawArraysIndirect(this, mode, indirect));
MarkShaderStorageBufferUsage(this);
}
void Context::drawElementsIndirect(PrimitiveMode mode, DrawElementsType type, const void *indirect)
{
ANGLE_CONTEXT_TRY(prepareForDraw(mode));
ANGLE_CONTEXT_TRY(mImplementation->drawElementsIndirect(this, mode, type, indirect));
MarkShaderStorageBufferUsage(this);
}
void Context::flush()
{
ANGLE_CONTEXT_TRY(mImplementation->flush(this));
}
void Context::finish()
{
ANGLE_CONTEXT_TRY(mImplementation->finish(this));
}
void Context::insertEventMarker(GLsizei length, const char *marker)
{
ASSERT(mImplementation);
mImplementation->insertEventMarker(length, marker);
}
void Context::pushGroupMarker(GLsizei length, const char *marker)
{
ASSERT(mImplementation);
if (marker == nullptr)
{
// From the EXT_debug_marker spec,
// "If <marker> is null then an empty string is pushed on the stack."
mImplementation->pushGroupMarker(length, "");
}
else
{
mImplementation->pushGroupMarker(length, marker);
}
}
void Context::popGroupMarker()
{
ASSERT(mImplementation);
mImplementation->popGroupMarker();
}
void Context::bindUniformLocation(ShaderProgramID program, GLint location, const GLchar *name)
{
Program *programObject = getProgramResolveLink(program);
ASSERT(programObject);
programObject->bindUniformLocation(location, name);
}
void Context::coverageModulation(GLenum components)
{
mState.setCoverageModulation(components);
}
void Context::matrixLoadf(GLenum matrixMode, const GLfloat *matrix)
{
mState.loadPathRenderingMatrix(matrixMode, matrix);
}
void Context::matrixLoadIdentity(GLenum matrixMode)
{
GLfloat I[16];
angle::Matrix<GLfloat>::setToIdentity(I);
mState.loadPathRenderingMatrix(matrixMode, I);
}
void Context::stencilFillPath(PathID path, GLenum fillMode, GLuint mask)
{
const auto *pathObj = mState.mPathManager->getPath(path);
if (!pathObj)
return;
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilFillPath(pathObj, fillMode, mask);
}
void Context::stencilStrokePath(PathID path, GLint reference, GLuint mask)
{
const auto *pathObj = mState.mPathManager->getPath(path);
if (!pathObj)
return;
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilStrokePath(pathObj, reference, mask);
}
void Context::coverFillPath(PathID path, GLenum coverMode)
{
const auto *pathObj = mState.mPathManager->getPath(path);
if (!pathObj)
return;
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->coverFillPath(pathObj, coverMode);
}
void Context::coverStrokePath(PathID path, GLenum coverMode)
{
const auto *pathObj = mState.mPathManager->getPath(path);
if (!pathObj)
return;
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->coverStrokePath(pathObj, coverMode);
}
void Context::stencilThenCoverFillPath(PathID path, GLenum fillMode, GLuint mask, GLenum coverMode)
{
const auto *pathObj = mState.mPathManager->getPath(path);
if (!pathObj)
return;
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilThenCoverFillPath(pathObj, fillMode, mask, coverMode);
}
void Context::stencilThenCoverStrokePath(PathID path,
GLint reference,
GLuint mask,
GLenum coverMode)
{
const auto *pathObj = mState.mPathManager->getPath(path);
if (!pathObj)
return;
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilThenCoverStrokePath(pathObj, reference, mask, coverMode);
}
void Context::coverFillPathInstanced(GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues)
{
const auto &pathObjects =
GatherPaths(*mState.mPathManager, numPaths, pathNameType, paths, pathBase);
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->coverFillPathInstanced(pathObjects, coverMode, transformType, transformValues);
}
void Context::coverStrokePathInstanced(GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues)
{
const auto &pathObjects =
GatherPaths(*mState.mPathManager, numPaths, pathNameType, paths, pathBase);
// TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->coverStrokePathInstanced(pathObjects, coverMode, transformType,
transformValues);
}
void Context::stencilFillPathInstanced(GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum fillMode,
GLuint mask,
GLenum transformType,
const GLfloat *transformValues)
{
const auto &pathObjects =
GatherPaths(*mState.mPathManager, numPaths, pathNameType, paths, pathBase);
// TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilFillPathInstanced(pathObjects, fillMode, mask, transformType,
transformValues);
}
void Context::stencilStrokePathInstanced(GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLint reference,
GLuint mask,
GLenum transformType,
const GLfloat *transformValues)
{
const auto &pathObjects =
GatherPaths(*mState.mPathManager, numPaths, pathNameType, paths, pathBase);
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilStrokePathInstanced(pathObjects, reference, mask, transformType,
transformValues);
}
void Context::stencilThenCoverFillPathInstanced(GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum fillMode,
GLuint mask,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues)
{
const auto &pathObjects =
GatherPaths(*mState.mPathManager, numPaths, pathNameType, paths, pathBase);
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilThenCoverFillPathInstanced(pathObjects, coverMode, fillMode, mask,
transformType, transformValues);
}
void Context::stencilThenCoverStrokePathInstanced(GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLint reference,
GLuint mask,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues)
{
const auto &pathObjects =
GatherPaths(*mState.mPathManager, numPaths, pathNameType, paths, pathBase);
ANGLE_CONTEXT_TRY(syncStateForPathOperation());
mImplementation->stencilThenCoverStrokePathInstanced(pathObjects, coverMode, reference, mask,
transformType, transformValues);
}
void Context::bindFragmentInputLocation(ShaderProgramID program, GLint location, const GLchar *name)
{
auto *programObject = getProgramResolveLink(program);
programObject->bindFragmentInputLocation(location, name);
}
void Context::programPathFragmentInputGen(ShaderProgramID program,
GLint location,
GLenum genMode,
GLint components,
const GLfloat *coeffs)
{
auto *programObject = getProgramResolveLink(program);
programObject->pathFragmentInputGen(location, genMode, components, coeffs);
}
GLuint Context::getProgramResourceIndex(ShaderProgramID program,
GLenum programInterface,
const GLchar *name)
{
const Program *programObject = getProgramResolveLink(program);
return QueryProgramResourceIndex(programObject, programInterface, name);
}
void Context::getProgramResourceName(ShaderProgramID program,
GLenum programInterface,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLchar *name)
{
const Program *programObject = getProgramResolveLink(program);
QueryProgramResourceName(programObject, programInterface, index, bufSize, length, name);
}
GLint Context::getProgramResourceLocation(ShaderProgramID program,
GLenum programInterface,
const GLchar *name)
{
const Program *programObject = getProgramResolveLink(program);
return QueryProgramResourceLocation(programObject, programInterface, name);
}
void Context::getProgramResourceiv(ShaderProgramID program,
GLenum programInterface,
GLuint index,
GLsizei propCount,
const GLenum *props,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
const Program *programObject = getProgramResolveLink(program);
QueryProgramResourceiv(programObject, programInterface, index, propCount, props, bufSize,
length, params);
}
void Context::getProgramInterfaceiv(ShaderProgramID program,
GLenum programInterface,
GLenum pname,
GLint *params)
{
const Program *programObject = getProgramResolveLink(program);
QueryProgramInterfaceiv(programObject, programInterface, pname, params);
}
void Context::getProgramInterfaceivRobust(ShaderProgramID program,
GLenum programInterface,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params)
{
UNIMPLEMENTED();
}
void Context::handleError(GLenum errorCode,
const char *message,
const char *file,
const char *function,
unsigned int line)
{
mErrors.handleError(errorCode, message, file, function, line);
}
void Context::validationError(GLenum errorCode, const char *message)
{
mErrors.validationError(errorCode, message);
}
// 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
{
return mErrors.popError();
}
}
// NOTE: this function should not assume that this context is current!
void Context::markContextLost(GraphicsResetStatus status)
{
ASSERT(status != GraphicsResetStatus::NoError);
if (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT)
{
mResetStatus = status;
mContextLostForced = true;
}
mContextLost = true;
}
GLenum Context::getGraphicsResetStatus()
{
// Even if the application doesn't want to know about resets, we want to know
// as it will allow us to skip all the calls.
if (mResetStrategy == GL_NO_RESET_NOTIFICATION_EXT)
{
if (!mContextLost && mImplementation->getResetStatus() != GraphicsResetStatus::NoError)
{
mContextLost = true;
}
// EXT_robustness, section 2.6: If the reset notification behavior is
// NO_RESET_NOTIFICATION_EXT, then the implementation will never deliver notification of
// reset events, and GetGraphicsResetStatusEXT will always return NO_ERROR.
return GL_NO_ERROR;
}
// The GL_EXT_robustness spec says that if a reset is encountered, a reset
// status should be returned at least once, and GL_NO_ERROR should be returned
// once the device has finished resetting.
if (!mContextLost)
{
ASSERT(mResetStatus == GraphicsResetStatus::NoError);
mResetStatus = mImplementation->getResetStatus();
if (mResetStatus != GraphicsResetStatus::NoError)
{
mContextLost = true;
}
}
else if (!mContextLostForced && mResetStatus != GraphicsResetStatus::NoError)
{
// If markContextLost was used to mark the context lost then
// assume that is not recoverable, and continue to report the
// lost reset status for the lifetime of this context.
mResetStatus = mImplementation->getResetStatus();
}
return ToGLenum(mResetStatus);
}
bool Context::isResetNotificationEnabled()
{
return (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT);
}
const egl::Config *Context::getConfig() const
{
return mConfig;
}
EGLenum Context::getClientType() const
{
return mState.getClientType();
}
EGLenum Context::getRenderBuffer() const
{
const Framebuffer *framebuffer =
mState.mFramebufferManager->getFramebuffer(Framebuffer::kDefaultDrawFramebufferHandle);
if (framebuffer == nullptr)
{
return EGL_NONE;
}
const FramebufferAttachment *backAttachment = framebuffer->getAttachment(this, GL_BACK);
ASSERT(backAttachment != nullptr);
return backAttachment->getSurface()->getRenderBuffer();
}
VertexArray *Context::checkVertexArrayAllocation(VertexArrayID vertexArrayHandle)
{
// Only called after a prior call to Gen.
VertexArray *vertexArray = getVertexArray(vertexArrayHandle);
if (!vertexArray)
{
vertexArray =
new VertexArray(mImplementation.get(), vertexArrayHandle,
mState.mCaps.maxVertexAttributes, mState.mCaps.maxVertexAttribBindings);
vertexArray->setBufferAccessValidationEnabled(mBufferAccessValidationEnabled);
mVertexArrayMap.assign(vertexArrayHandle, vertexArray);
}
return vertexArray;
}
TransformFeedback *Context::checkTransformFeedbackAllocation(
TransformFeedbackID transformFeedbackHandle)
{
// Only called after a prior call to Gen.
TransformFeedback *transformFeedback = getTransformFeedback(transformFeedbackHandle);
if (!transformFeedback)
{
transformFeedback =
new TransformFeedback(mImplementation.get(), transformFeedbackHandle, mState.mCaps);
transformFeedback->addRef();
mTransformFeedbackMap.assign(transformFeedbackHandle, transformFeedback);
}
return transformFeedback;
}
bool Context::isVertexArrayGenerated(VertexArrayID vertexArray)
{
ASSERT(mVertexArrayMap.contains({0}));
return mVertexArrayMap.contains(vertexArray);
}
bool Context::isTransformFeedbackGenerated(TransformFeedbackID transformFeedback)
{
ASSERT(mTransformFeedbackMap.contains({0}));
return mTransformFeedbackMap.contains(transformFeedback);
}
void Context::detachTexture(TextureID texture)
{
// The State cannot unbind image observers itself, they are owned by the Context
Texture *tex = mState.mTextureManager->getTexture(texture);
for (auto &imageBinding : mImageObserverBindings)
{
if (imageBinding.getSubject() == tex)
{
imageBinding.reset();
}
}
// 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(this, mZeroTextures, texture);
}
void Context::detachBuffer(Buffer *buffer)
{
// Simple pass-through to State's detachBuffer method, since
// only buffer attachments to container objects that are bound to the current context
// should be detached. And all those are available in State.
// [OpenGL ES 3.2] section 5.1.2 page 45:
// Attachments to unbound container objects, such as
// deletion of a buffer attached to a vertex array object which is not bound to the context,
// are not affected and continue to act as references on the deleted object
ANGLE_CONTEXT_TRY(mState.detachBuffer(this, buffer));
}
void Context::detachFramebuffer(FramebufferID 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.value != 0)
{
bindReadFramebuffer({0});
}
if (mState.removeDrawFramebufferBinding(framebuffer) && framebuffer.value != 0)
{
bindDrawFramebuffer({0});
}
}
void Context::detachRenderbuffer(RenderbufferID renderbuffer)
{
mState.detachRenderbuffer(this, renderbuffer);
}
void Context::detachVertexArray(VertexArrayID 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(this, vertexArray))
{
bindVertexArray({0});
}
}
void Context::detachTransformFeedback(TransformFeedbackID transformFeedback)
{
// Transform feedback detachment is handled by Context, because 0 is a valid
// transform feedback, and a pointer to it must be passed from Context to State at
// binding time.
// The OpenGL specification doesn't mention what should happen when the currently bound
// transform feedback object is deleted. Since it is a container object, we treat it like
// VAOs and FBOs and set the current bound transform feedback back to 0.
if (mState.removeTransformFeedbackBinding(this, transformFeedback))
{
bindTransformFeedback(GL_TRANSFORM_FEEDBACK, {0});
}
}
void Context::detachSampler(SamplerID sampler)
{
mState.detachSampler(this, sampler);
}
void Context::detachProgramPipeline(ProgramPipelineID pipeline)
{
mState.detachProgramPipeline(this, pipeline);
}
void Context::vertexAttribDivisor(GLuint index, GLuint divisor)
{
mState.setVertexAttribDivisor(this, index, divisor);
mStateCache.onVertexArrayStateChange(this);
}
void Context::samplerParameteri(SamplerID sampler, GLenum pname, GLint param)
{
Sampler *const samplerObject =
mState.mSamplerManager->checkSamplerAllocation(mImplementation.get(), sampler);
SetSamplerParameteri(this, samplerObject, pname, param);
}
void Context::samplerParameteriv(SamplerID sampler, GLenum pname, const GLint *param)
{
Sampler *const samplerObject =
mState.mSamplerManager->checkSamplerAllocation(mImplementation.get(), sampler);
SetSamplerParameteriv(this, samplerObject, pname, param);
}
void Context::samplerParameterIiv(SamplerID sampler, GLenum pname, const GLint *param)
{
Sampler *const samplerObject =
mState.mSamplerManager->checkSamplerAllocation(mImplementation.get(), sampler);
SetSamplerParameterIiv(this, samplerObject, pname, param);