summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/angle/src/libANGLE/Context.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/Context.cpp')
-rw-r--r--src/3rdparty/angle/src/libANGLE/Context.cpp5558
1 files changed, 0 insertions, 5558 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/Context.cpp b/src/3rdparty/angle/src/libANGLE/Context.cpp
deleted file mode 100644
index f638beda58..0000000000
--- a/src/3rdparty/angle/src/libANGLE/Context.cpp
+++ /dev/null
@@ -1,5558 +0,0 @@
-//
-// 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 <string.h>
-#include <iterator>
-#include <sstream>
-#include <vector>
-
-#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/Framebuffer.h"
-#include "libANGLE/FramebufferAttachment.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/Surface.h"
-#include "libANGLE/Texture.h"
-#include "libANGLE/TransformFeedback.h"
-#include "libANGLE/VertexArray.h"
-#include "libANGLE/Workarounds.h"
-#include "libANGLE/formatutils.h"
-#include "libANGLE/queryconversions.h"
-#include "libANGLE/queryutils.h"
-#include "libANGLE/renderer/ContextImpl.h"
-#include "libANGLE/renderer/EGLImplFactory.h"
-#include "libANGLE/renderer/Format.h"
-#include "libANGLE/validationES.h"
-
-namespace
-{
-
-#define ANGLE_HANDLE_ERR(X) \
- handleError(X); \
- return;
-#define ANGLE_CONTEXT_TRY(EXPR) ANGLE_TRY_TEMPLATE(EXPR, ANGLE_HANDLE_ERR);
-
-template <typename T>
-std::vector<gl::Path *> GatherPaths(gl::PathManager &resourceManager,
- GLsizei numPaths,
- const void *paths,
- GLuint pathBase)
-{
- std::vector<gl::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;
-
- ret.push_back(resourceManager.getPath(pathName));
- }
-
- return ret;
-}
-
-std::vector<gl::Path *> GatherPaths(gl::PathManager &resourceManager,
- GLsizei numPaths,
- GLenum pathNameType,
- const void *paths,
- GLuint 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<gl::Path *>();
-}
-
-template <typename T>
-gl::Error GetQueryObjectParameter(gl::Query *query, GLenum pname, T *params)
-{
- ASSERT(query != nullptr);
-
- switch (pname)
- {
- case GL_QUERY_RESULT_EXT:
- return query->getResult(params);
- case GL_QUERY_RESULT_AVAILABLE_EXT:
- {
- bool available;
- gl::Error error = query->isResultAvailable(&available);
- if (!error.isError())
- {
- *params = gl::CastFromStateValue<T>(pname, static_cast<GLuint>(available));
- }
- return error;
- }
- default:
- UNREACHABLE();
- return gl::InternalError() << "Unreachable Error";
- }
-}
-
-void MarkTransformFeedbackBufferUsage(gl::TransformFeedback *transformFeedback)
-{
- if (transformFeedback && transformFeedback->isActive() && !transformFeedback->isPaused())
- {
- for (size_t tfBufferIndex = 0; tfBufferIndex < transformFeedback->getIndexedBufferCount();
- tfBufferIndex++)
- {
- const gl::OffsetBindingPointer<gl::Buffer> &buffer =
- transformFeedback->getIndexedBuffer(tfBufferIndex);
- if (buffer.get() != nullptr)
- {
- buffer->onTransformFeedback();
- }
- }
- }
-}
-
-// 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));
-}
-
-gl::Version GetClientVersion(const egl::AttributeMap &attribs)
-{
- return gl::Version(GetClientMajorVersion(attribs), GetClientMinorVersion(attribs));
-}
-
-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 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);
- }
-}
-
-template <typename CapT, typename MaxT>
-void LimitCap(CapT *cap, MaxT maximum)
-{
- *cap = std::min(*cap, static_cast<CapT>(maximum));
-}
-
-} // anonymous namespace
-
-namespace gl
-{
-
-Context::Context(rx::EGLImplFactory *implFactory,
- const egl::Config *config,
- const Context *shareContext,
- TextureManager *shareTextures,
- MemoryProgramCache *memoryProgramCache,
- const egl::AttributeMap &attribs,
- const egl::DisplayExtensions &displayExtensions)
-
- : ValidationContext(shareContext,
- shareTextures,
- GetClientVersion(attribs),
- &mGLState,
- mCaps,
- mTextureCaps,
- mExtensions,
- mLimitations,
- GetNoError(attribs)),
- mImplementation(implFactory->createContext(mState)),
- mCompiler(),
- mConfig(config),
- mClientType(EGL_OPENGL_ES_API),
- mHasBeenCurrent(false),
- mContextLost(false),
- mResetStatus(GL_NO_ERROR),
- mContextLostForced(false),
- mResetStrategy(GetResetStrategy(attribs)),
- mRobustAccess(GetRobustAccess(attribs)),
- mCurrentSurface(static_cast<egl::Surface *>(EGL_NO_SURFACE)),
- mCurrentDisplay(static_cast<egl::Display *>(EGL_NO_DISPLAY)),
- mSurfacelessFramebuffer(nullptr),
- mWebGLContext(GetWebGLContext(attribs)),
- mMemoryProgramCache(memoryProgramCache),
- mScratchBuffer(1000u),
- mZeroFilledBuffer(1000u)
-{
- mImplementation->setMemoryProgramCache(memoryProgramCache);
-
- bool robustResourceInit = GetRobustResourceInit(attribs);
- initCaps(displayExtensions, robustResourceInit);
- initWorkarounds();
-
- mGLState.initialize(this, GetDebug(attribs), GetBindGeneratesResource(attribs),
- GetClientArraysEnabled(attribs), robustResourceInit,
- mMemoryProgramCache != nullptr);
-
- 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, GL_TEXTURE_2D);
- mZeroTextures[GL_TEXTURE_2D].set(this, zeroTexture2D);
-
- Texture *zeroTextureCube = new Texture(mImplementation.get(), 0, GL_TEXTURE_CUBE_MAP);
- mZeroTextures[GL_TEXTURE_CUBE_MAP].set(this, zeroTextureCube);
-
- if (getClientVersion() >= Version(3, 0))
- {
- // TODO: These could also be enabled via extension
- Texture *zeroTexture3D = new Texture(mImplementation.get(), 0, GL_TEXTURE_3D);
- mZeroTextures[GL_TEXTURE_3D].set(this, zeroTexture3D);
-
- Texture *zeroTexture2DArray = new Texture(mImplementation.get(), 0, GL_TEXTURE_2D_ARRAY);
- mZeroTextures[GL_TEXTURE_2D_ARRAY].set(this, zeroTexture2DArray);
- }
- if (getClientVersion() >= Version(3, 1))
- {
- Texture *zeroTexture2DMultisample =
- new Texture(mImplementation.get(), 0, GL_TEXTURE_2D_MULTISAMPLE);
- mZeroTextures[GL_TEXTURE_2D_MULTISAMPLE].set(this, zeroTexture2DMultisample);
-
- for (unsigned int i = 0; i < mCaps.maxAtomicCounterBufferBindings; i++)
- {
- bindBufferRange(BufferBinding::AtomicCounter, 0, i, 0, 0);
- }
-
- for (unsigned int i = 0; i < mCaps.maxShaderStorageBufferBindings; i++)
- {
- bindBufferRange(BufferBinding::ShaderStorage, i, 0, 0, 0);
- }
- }
-
- const Extensions &nativeExtensions = mImplementation->getNativeExtensions();
- if (nativeExtensions.textureRectangle)
- {
- Texture *zeroTextureRectangle =
- new Texture(mImplementation.get(), 0, GL_TEXTURE_RECTANGLE_ANGLE);
- mZeroTextures[GL_TEXTURE_RECTANGLE_ANGLE].set(this, zeroTextureRectangle);
- }
-
- if (nativeExtensions.eglImageExternal || nativeExtensions.eglStreamConsumerExternal)
- {
- Texture *zeroTextureExternal =
- new Texture(mImplementation.get(), 0, GL_TEXTURE_EXTERNAL_OES);
- mZeroTextures[GL_TEXTURE_EXTERNAL_OES].set(this, zeroTextureExternal);
- }
-
- mGLState.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 (unsigned int i = 0; i < mCaps.maxUniformBufferBindings; i++)
- {
- bindBufferRange(BufferBinding::Uniform, i, 0, 0, -1);
- }
-
- // Initialize dirty bit masks
- 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);
- 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);
- mClearDirtyObjects.set(State::DIRTY_OBJECT_DRAW_FRAMEBUFFER);
-
- mBlitDirtyBits.set(State::DIRTY_BIT_SCISSOR_TEST_ENABLED);
- mBlitDirtyBits.set(State::DIRTY_BIT_SCISSOR);
- mBlitDirtyBits.set(State::DIRTY_BIT_FRAMEBUFFER_SRGB);
- mBlitDirtyObjects.set(State::DIRTY_OBJECT_READ_FRAMEBUFFER);
- mBlitDirtyObjects.set(State::DIRTY_OBJECT_DRAW_FRAMEBUFFER);
-
- handleError(mImplementation->initialize());
-}
-
-egl::Error Context::onDestroy(const egl::Display *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 (auto &zeroTexture : mZeroTextures)
- {
- ANGLE_TRY(zeroTexture.second->onDestroy(this));
- zeroTexture.second.set(this, nullptr);
- }
- mZeroTextures.clear();
-
- SafeDelete(mSurfacelessFramebuffer);
-
- ANGLE_TRY(releaseSurface(display));
- releaseShaderCompiler();
-
- mGLState.reset(this);
-
- mState.mBuffers->release(this);
- mState.mShaderPrograms->release(this);
- mState.mTextures->release(this);
- mState.mRenderbuffers->release(this);
- mState.mSamplers->release(this);
- mState.mSyncs->release(this);
- mState.mPaths->release(this);
- mState.mFramebuffers->release(this);
- mState.mPipelines->release(this);
-
- mImplementation->onDestroy(this);
-
- return egl::NoError();
-}
-
-Context::~Context()
-{
-}
-
-egl::Error Context::makeCurrent(egl::Display *display, egl::Surface *surface)
-{
- mCurrentDisplay = display;
-
- if (!mHasBeenCurrent)
- {
- initRendererString();
- initVersionStrings();
- initExtensionStrings();
-
- int width = 0;
- int height = 0;
- if (surface != nullptr)
- {
- width = surface->getWidth();
- height = surface->getHeight();
- }
-
- mGLState.setViewportParams(0, 0, width, height);
- mGLState.setScissorParams(0, 0, width, height);
-
- mHasBeenCurrent = true;
- }
-
- // TODO(jmadill): Rework this when we support ContextImpl
- mGLState.setAllDirtyBits();
- mGLState.setAllDirtyObjects();
-
- ANGLE_TRY(releaseSurface(display));
-
- Framebuffer *newDefault = nullptr;
- if (surface != nullptr)
- {
- ANGLE_TRY(surface->setIsCurrent(this, true));
- mCurrentSurface = surface;
- newDefault = surface->getDefaultFramebuffer();
- }
- else
- {
- if (mSurfacelessFramebuffer == nullptr)
- {
- mSurfacelessFramebuffer = new Framebuffer(mImplementation.get());
- }
-
- newDefault = mSurfacelessFramebuffer;
- }
-
- // Update default framebuffer, the binding of the previous default
- // framebuffer (or lack of) will have a nullptr.
- {
- if (mGLState.getReadFramebuffer() == nullptr)
- {
- mGLState.setReadFramebufferBinding(newDefault);
- }
- if (mGLState.getDrawFramebuffer() == nullptr)
- {
- mGLState.setDrawFramebufferBinding(newDefault);
- }
- mState.mFramebuffers->setDefaultFramebuffer(newDefault);
- }
-
- // Notify the renderer of a context switch
- mImplementation->onMakeCurrent(this);
- return egl::NoError();
-}
-
-egl::Error Context::releaseSurface(const egl::Display *display)
-{
- // Remove the default framebuffer
- Framebuffer *currentDefault = nullptr;
- if (mCurrentSurface != nullptr)
- {
- currentDefault = mCurrentSurface->getDefaultFramebuffer();
- }
- else if (mSurfacelessFramebuffer != nullptr)
- {
- currentDefault = mSurfacelessFramebuffer;
- }
-
- if (mGLState.getReadFramebuffer() == currentDefault)
- {
- mGLState.setReadFramebufferBinding(nullptr);
- }
- if (mGLState.getDrawFramebuffer() == currentDefault)
- {
- mGLState.setDrawFramebufferBinding(nullptr);
- }
- mState.mFramebuffers->setDefaultFramebuffer(nullptr);
-
- if (mCurrentSurface)
- {
- ANGLE_TRY(mCurrentSurface->setIsCurrent(this, false));
- mCurrentSurface = nullptr;
- }
-
- return egl::NoError();
-}
-
-GLuint Context::createBuffer()
-{
- return mState.mBuffers->createBuffer();
-}
-
-GLuint Context::createProgram()
-{
- return mState.mShaderPrograms->createProgram(mImplementation.get());
-}
-
-GLuint Context::createShader(GLenum type)
-{
- return mState.mShaderPrograms->createShader(mImplementation.get(), mLimitations, type);
-}
-
-GLuint Context::createTexture()
-{
- return mState.mTextures->createTexture();
-}
-
-GLuint Context::createRenderbuffer()
-{
- return mState.mRenderbuffers->createRenderbuffer();
-}
-
-GLuint Context::createPaths(GLsizei range)
-{
- auto resultOrError = mState.mPaths->createPaths(mImplementation.get(), range);
- if (resultOrError.isError())
- {
- handleError(resultOrError.getError());
- return 0;
- }
- return resultOrError.getResult();
-}
-
-// Returns an unused framebuffer name
-GLuint Context::createFramebuffer()
-{
- return mState.mFramebuffers->createFramebuffer();
-}
-
-GLuint Context::createFenceNV()
-{
- GLuint handle = mFenceNVHandleAllocator.allocate();
- mFenceNVMap.assign(handle, new FenceNV(mImplementation->createFenceNV()));
- return handle;
-}
-
-GLuint Context::createProgramPipeline()
-{
- return mState.mPipelines->createProgramPipeline();
-}
-
-GLuint Context::createShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
-{
- UNIMPLEMENTED();
- return 0u;
-}
-
-void Context::deleteBuffer(GLuint buffer)
-{
- if (mState.mBuffers->getBuffer(buffer))
- {
- detachBuffer(buffer);
- }
-
- mState.mBuffers->deleteObject(this, buffer);
-}
-
-void Context::deleteShader(GLuint shader)
-{
- mState.mShaderPrograms->deleteShader(this, shader);
-}
-
-void Context::deleteProgram(GLuint program)
-{
- mState.mShaderPrograms->deleteProgram(this, program);
-}
-
-void Context::deleteTexture(GLuint texture)
-{
- if (mState.mTextures->getTexture(texture))
- {
- detachTexture(texture);
- }
-
- mState.mTextures->deleteObject(this, texture);
-}
-
-void Context::deleteRenderbuffer(GLuint renderbuffer)
-{
- if (mState.mRenderbuffers->getRenderbuffer(renderbuffer))
- {
- detachRenderbuffer(renderbuffer);
- }
-
- mState.mRenderbuffers->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.mSyncs->deleteObject(this, static_cast<GLuint>(reinterpret_cast<uintptr_t>(sync)));
-}
-
-void Context::deleteProgramPipeline(GLuint pipeline)
-{
- if (mState.mPipelines->getProgramPipeline(pipeline))
- {
- detachProgramPipeline(pipeline);
- }
-
- mState.mPipelines->deleteObject(this, pipeline);
-}
-
-void Context::deletePaths(GLuint first, GLsizei range)
-{
- mState.mPaths->deletePaths(first, range);
-}
-
-bool Context::hasPathData(GLuint path) const
-{
- const auto *pathObj = mState.mPaths->getPath(path);
- if (pathObj == nullptr)
- return false;
-
- return pathObj->hasPathData();
-}
-
-bool Context::hasPath(GLuint path) const
-{
- return mState.mPaths->hasPath(path);
-}
-
-void Context::setPathCommands(GLuint path,
- GLsizei numCommands,
- const GLubyte *commands,
- GLsizei numCoords,
- GLenum coordType,
- const void *coords)
-{
- auto *pathObject = mState.mPaths->getPath(path);
-
- handleError(pathObject->setCommands(numCommands, commands, numCoords, coordType, coords));
-}
-
-void Context::setPathParameterf(GLuint path, GLenum pname, GLfloat value)
-{
- auto *pathObj = mState.mPaths->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::getPathParameterfv(GLuint path, GLenum pname, GLfloat *value) const
-{
- const auto *pathObj = mState.mPaths->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::setPathStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
- mGLState.setPathStencilFunc(func, ref, mask);
-}
-
-void Context::deleteFramebuffer(GLuint framebuffer)
-{
- if (mState.mFramebuffers->getFramebuffer(framebuffer))
- {
- detachFramebuffer(framebuffer);
- }
-
- mState.mFramebuffers->deleteObject(this, framebuffer);
-}
-
-void Context::deleteFenceNV(GLuint fence)
-{
- FenceNV *fenceObject = nullptr;
- if (mFenceNVMap.erase(fence, &fenceObject))
- {
- mFenceNVHandleAllocator.release(fence);
- delete fenceObject;
- }
-}
-
-Buffer *Context::getBuffer(GLuint handle) const
-{
- return mState.mBuffers->getBuffer(handle);
-}
-
-Texture *Context::getTexture(GLuint handle) const
-{
- return mState.mTextures->getTexture(handle);
-}
-
-Renderbuffer *Context::getRenderbuffer(GLuint handle) const
-{
- return mState.mRenderbuffers->getRenderbuffer(handle);
-}
-
-Sync *Context::getSync(GLsync handle) const
-{
- return mState.mSyncs->getSync(static_cast<GLuint>(reinterpret_cast<uintptr_t>(handle)));
-}
-
-VertexArray *Context::getVertexArray(GLuint handle) const
-{
- return mVertexArrayMap.query(handle);
-}
-
-Sampler *Context::getSampler(GLuint handle) const
-{
- return mState.mSamplers->getSampler(handle);
-}
-
-TransformFeedback *Context::getTransformFeedback(GLuint handle) const
-{
- return mTransformFeedbackMap.query(handle);
-}
-
-ProgramPipeline *Context::getProgramPipeline(GLuint handle) const
-{
- return mState.mPipelines->getProgramPipeline(handle);
-}
-
-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 getProgram(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;
- }
-}
-
-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)
-{
- LabeledObject *object = getLabeledObject(identifier, name);
- ASSERT(object != nullptr);
-
- std::string labelName = GetObjectLabelFromPointer(length, label);
- object->setLabel(labelName);
-
- // TODO(jmadill): Determine if the object is dirty based on 'name'. Conservatively assume the
- // specified object is active until we do this.
- mGLState.setObjectDirty(identifier);
-}
-
-void Context::objectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
-{
- LabeledObject *object = getLabeledObjectFromPtr(ptr);
- ASSERT(object != nullptr);
-
- std::string labelName = GetObjectLabelFromPointer(length, label);
- object->setLabel(labelName);
-}
-
-void Context::getObjectLabel(GLenum identifier,
- GLuint name,
- GLsizei bufSize,
- GLsizei *length,
- GLchar *label) const
-{
- 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) const
-{
- LabeledObject *object = getLabeledObjectFromPtr(ptr);
- ASSERT(object != nullptr);
-
- const std::string &objectLabel = object->getLabel();
- GetObjectLabelBase(objectLabel, bufSize, length, label);
-}
-
-bool Context::isSampler(GLuint samplerName) const
-{
- return mState.mSamplers->isSampler(samplerName);
-}
-
-void Context::bindTexture(GLenum target, GLuint handle)
-{
- Texture *texture = nullptr;
-
- if (handle == 0)
- {
- texture = mZeroTextures[target].get();
- }
- else
- {
- texture = mState.mTextures->checkTextureAllocation(mImplementation.get(), handle, target);
- }
-
- ASSERT(texture);
- mGLState.setSamplerTexture(this, target, texture);
-}
-
-void Context::bindReadFramebuffer(GLuint framebufferHandle)
-{
- Framebuffer *framebuffer = mState.mFramebuffers->checkFramebufferAllocation(
- mImplementation.get(), mCaps, framebufferHandle);
- mGLState.setReadFramebufferBinding(framebuffer);
-}
-
-void Context::bindDrawFramebuffer(GLuint framebufferHandle)
-{
- Framebuffer *framebuffer = mState.mFramebuffers->checkFramebufferAllocation(
- mImplementation.get(), mCaps, framebufferHandle);
- mGLState.setDrawFramebufferBinding(framebuffer);
-}
-
-void Context::bindVertexArray(GLuint vertexArrayHandle)
-{
- VertexArray *vertexArray = checkVertexArrayAllocation(vertexArrayHandle);
- mGLState.setVertexArrayBinding(vertexArray);
-}
-
-void Context::bindVertexBuffer(GLuint bindingIndex,
- GLuint bufferHandle,
- GLintptr offset,
- GLsizei stride)
-{
- Buffer *buffer = mState.mBuffers->checkBufferAllocation(mImplementation.get(), bufferHandle);
- mGLState.bindVertexBuffer(this, bindingIndex, buffer, offset, stride);
-}
-
-void Context::bindSampler(GLuint textureUnit, GLuint samplerHandle)
-{
- ASSERT(textureUnit < mCaps.maxCombinedTextureImageUnits);
- Sampler *sampler =
- mState.mSamplers->checkSamplerAllocation(mImplementation.get(), samplerHandle);
- mGLState.setSamplerBinding(this, textureUnit, sampler);
-}
-
-void Context::bindImageTexture(GLuint unit,
- GLuint texture,
- GLint level,
- GLboolean layered,
- GLint layer,
- GLenum access,
- GLenum format)
-{
- Texture *tex = mState.mTextures->getTexture(texture);
- mGLState.setImageUnit(this, unit, tex, level, layered, layer, access, format);
-}
-
-void Context::useProgram(GLuint program)
-{
- mGLState.setProgram(this, getProgram(program));
-}
-
-void Context::useProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
- UNIMPLEMENTED();
-}
-
-void Context::bindTransformFeedback(GLenum target, GLuint transformFeedbackHandle)
-{
- ASSERT(target == GL_TRANSFORM_FEEDBACK);
- TransformFeedback *transformFeedback =
- checkTransformFeedbackAllocation(transformFeedbackHandle);
- mGLState.setTransformFeedbackBinding(this, transformFeedback);
-}
-
-void Context::bindProgramPipeline(GLuint pipelineHandle)
-{
- ProgramPipeline *pipeline =
- mState.mPipelines->checkProgramPipelineAllocation(mImplementation.get(), pipelineHandle);
- mGLState.setProgramPipelineBinding(this, pipeline);
-}
-
-void Context::beginQuery(GLenum target, GLuint query)
-{
- Query *queryObject = getQuery(query, true, target);
- ASSERT(queryObject);
-
- // begin query
- ANGLE_CONTEXT_TRY(queryObject->begin());
-
- // set query as active for specified target only if begin succeeded
- mGLState.setActiveQuery(this, target, queryObject);
-}
-
-void Context::endQuery(GLenum target)
-{
- Query *queryObject = mGLState.getActiveQuery(target);
- ASSERT(queryObject);
-
- handleError(queryObject->end());
-
- // Always unbind the query, even if there was an error. This may delete the query object.
- mGLState.setActiveQuery(this, target, nullptr);
-}
-
-void Context::queryCounter(GLuint id, GLenum target)
-{
- ASSERT(target == GL_TIMESTAMP_EXT);
-
- Query *queryObject = getQuery(id, true, target);
- ASSERT(queryObject);
-
- handleError(queryObject->queryCounter());
-}
-
-void Context::getQueryiv(GLenum target, GLenum pname, GLint *params)
-{
- switch (pname)
- {
- case GL_CURRENT_QUERY_EXT:
- params[0] = mGLState.getActiveQueryId(target);
- break;
- case GL_QUERY_COUNTER_BITS_EXT:
- switch (target)
- {
- case GL_TIME_ELAPSED_EXT:
- params[0] = getExtensions().queryCounterBitsTimeElapsed;
- break;
- case GL_TIMESTAMP_EXT:
- params[0] = getExtensions().queryCounterBitsTimestamp;
- break;
- default:
- UNREACHABLE();
- params[0] = 0;
- break;
- }
- break;
- default:
- UNREACHABLE();
- return;
- }
-}
-
-void Context::getQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-{
- handleError(GetQueryObjectParameter(getQuery(id), pname, params));
-}
-
-void Context::getQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-{
- handleError(GetQueryObjectParameter(getQuery(id), pname, params));
-}
-
-void Context::getQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
-{
- handleError(GetQueryObjectParameter(getQuery(id), pname, params));
-}
-
-void Context::getQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
-{
- handleError(GetQueryObjectParameter(getQuery(id), pname, params));
-}
-
-Framebuffer *Context::getFramebuffer(GLuint handle) const
-{
- return mState.mFramebuffers->getFramebuffer(handle);
-}
-
-FenceNV *Context::getFenceNV(GLuint handle)
-{
- return mFenceNVMap.query(handle);
-}
-
-Query *Context::getQuery(GLuint handle, bool create, GLenum type)
-{
- if (!mQueryMap.contains(handle))
- {
- return nullptr;
- }
-
- Query *query = mQueryMap.query(handle);
- if (!query && create)
- {
- query = new Query(mImplementation->createQuery(type), handle);
- query->addRef();
- mQueryMap.assign(handle, query);
- }
- return query;
-}
-
-Query *Context::getQuery(GLuint handle) const
-{
- return mQueryMap.query(handle);
-}
-
-Texture *Context::getTargetTexture(GLenum target) const
-{
- ASSERT(ValidTextureTarget(this, target) || ValidTextureExternalTarget(this, target));
- return mGLState.getTargetTexture(target);
-}
-
-Texture *Context::getSamplerTexture(unsigned int sampler, GLenum type) const
-{
- return mGLState.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 = mRobustAccess ? GL_TRUE : GL_FALSE;
- break;
- default:
- mGLState.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] = 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;
-
- case GL_PATH_MODELVIEW_MATRIX_CHROMIUM:
- case GL_PATH_PROJECTION_MATRIX_CHROMIUM:
- {
- ASSERT(mExtensions.pathRendering);
- const GLfloat *m = mGLState.getPathRenderingMatrix(pname);
- memcpy(params, m, 16 * sizeof(GLfloat));
- }
- break;
-
- default:
- mGLState.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 = 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.maxFragmentUniformComponents;
- 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_RECTANGLE_TEXTURE_SIZE_ANGLE:
- *params = mCaps.maxRectangleTextureSize;
- 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 = getClientVersion().major;
- break;
- case GL_MINOR_VERSION:
- *params = getClientVersion().minor;
- 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 = static_cast<GLint>(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 = static_cast<GLint>(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 = static_cast<GLint>(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;
-
- // GL_KHR_debug
- case GL_MAX_DEBUG_MESSAGE_LENGTH:
- *params = mExtensions.maxDebugMessageLength;
- break;
- case GL_MAX_DEBUG_LOGGED_MESSAGES:
- *params = mExtensions.maxDebugLoggedMessages;
- break;
- case GL_MAX_DEBUG_GROUP_STACK_DEPTH:
- *params = mExtensions.maxDebugGroupStackDepth;
- break;
- case GL_MAX_LABEL_LENGTH:
- *params = mExtensions.maxLabelLength;
- break;
-
- // GL_ANGLE_multiview
- case GL_MAX_VIEWS_ANGLE:
- *params = mExtensions.maxViews;
- break;
-
- // GL_EXT_disjoint_timer_query
- case GL_GPU_DISJOINT_EXT:
- *params = mImplementation->getGPUDisjoint();
- break;
- case GL_MAX_FRAMEBUFFER_WIDTH:
- *params = mCaps.maxFramebufferWidth;
- break;
- case GL_MAX_FRAMEBUFFER_HEIGHT:
- *params = mCaps.maxFramebufferHeight;
- break;
- case GL_MAX_FRAMEBUFFER_SAMPLES:
- *params = mCaps.maxFramebufferSamples;
- break;
- case GL_MAX_SAMPLE_MASK_WORDS:
- *params = mCaps.maxSampleMaskWords;
- break;
- case GL_MAX_COLOR_TEXTURE_SAMPLES:
- *params = mCaps.maxColorTextureSamples;
- break;
- case GL_MAX_DEPTH_TEXTURE_SAMPLES:
- *params = mCaps.maxDepthTextureSamples;
- break;
- case GL_MAX_INTEGER_SAMPLES:
- *params = mCaps.maxIntegerSamples;
- break;
- case GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
- *params = mCaps.maxVertexAttribRelativeOffset;
- break;
- case GL_MAX_VERTEX_ATTRIB_BINDINGS:
- *params = mCaps.maxVertexAttribBindings;
- break;
- case GL_MAX_VERTEX_ATTRIB_STRIDE:
- *params = mCaps.maxVertexAttribStride;
- break;
- case GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
- *params = mCaps.maxVertexAtomicCounterBuffers;
- break;
- case GL_MAX_VERTEX_ATOMIC_COUNTERS:
- *params = mCaps.maxVertexAtomicCounters;
- break;
- case GL_MAX_VERTEX_IMAGE_UNIFORMS:
- *params = mCaps.maxVertexImageUniforms;
- break;
- case GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
- *params = mCaps.maxVertexShaderStorageBlocks;
- break;
- case GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
- *params = mCaps.maxFragmentAtomicCounterBuffers;
- break;
- case GL_MAX_FRAGMENT_ATOMIC_COUNTERS:
- *params = mCaps.maxFragmentAtomicCounters;
- break;
- case GL_MAX_FRAGMENT_IMAGE_UNIFORMS:
- *params = mCaps.maxFragmentImageUniforms;
- break;
- case GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
- *params = mCaps.maxFragmentShaderStorageBlocks;
- break;
- case GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
- *params = mCaps.minProgramTextureGatherOffset;
- break;
- case GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
- *params = mCaps.maxProgramTextureGatherOffset;
- break;
- case GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS:
- *params = mCaps.maxComputeWorkGroupInvocations;
- break;
- case GL_MAX_COMPUTE_UNIFORM_BLOCKS:
- *params = mCaps.maxComputeUniformBlocks;
- break;
- case GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
- *params = mCaps.maxComputeTextureImageUnits;
- break;
- case GL_MAX_COMPUTE_SHARED_MEMORY_SIZE:
- *params = mCaps.maxComputeSharedMemorySize;
- break;
- case GL_MAX_COMPUTE_UNIFORM_COMPONENTS:
- *params = mCaps.maxComputeUniformComponents;
- break;
- case GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
- *params = mCaps.maxComputeAtomicCounterBuffers;
- break;
- case GL_MAX_COMPUTE_ATOMIC_COUNTERS:
- *params = mCaps.maxComputeAtomicCounters;
- break;
- case GL_MAX_COMPUTE_IMAGE_UNIFORMS:
- *params = mCaps.maxComputeImageUniforms;
- break;
- case GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS:
- *params = mCaps.maxCombinedComputeUniformComponents;
- break;
- case GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
- *params = mCaps.maxComputeShaderStorageBlocks;
- break;
- case GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
- *params = mCaps.maxCombinedShaderOutputResources;
- break;
- case GL_MAX_UNIFORM_LOCATIONS:
- *params = mCaps.maxUniformLocations;
- break;
- case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
- *params = mCaps.maxAtomicCounterBufferBindings;
- break;
- case GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
- *params = mCaps.maxAtomicCounterBufferSize;
- break;
- case GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS:
- *params = mCaps.maxCombinedAtomicCounterBuffers;
- break;
- case GL_MAX_COMBINED_ATOMIC_COUNTERS:
- *params = mCaps.maxCombinedAtomicCounters;
- break;
- case GL_MAX_IMAGE_UNITS:
- *params = mCaps.maxImageUnits;
- break;
- case GL_MAX_COMBINED_IMAGE_UNIFORMS:
- *params = mCaps.maxCombinedImageUniforms;
- break;
- case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
- *params = mCaps.maxShaderStorageBufferBindings;
- break;
- case GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
- *params = mCaps.maxCombinedShaderStorageBlocks;
- break;
- case GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
- *params = mCaps.shaderStorageBufferOffsetAlignment;
- break;
- default:
- mGLState.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 = 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;
-
- // GL_EXT_disjoint_timer_query
- case GL_TIMESTAMP_EXT:
- *params = mImplementation->getTimestamp();
- break;
-
- case GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
- *params = mCaps.maxShaderStorageBlockSize;
- break;
- default:
- UNREACHABLE();
- break;
- }
-}
-
-void Context::getPointerv(GLenum pname, void **params) const
-{
- mGLState.getPointerv(pname, params);
-}
-
-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 = mCaps.maxComputeWorkGroupCount[index];
- break;
- case GL_MAX_COMPUTE_WORK_GROUP_SIZE:
- ASSERT(index < 3u);
- *data = mCaps.maxComputeWorkGroupSize[index];
- break;
- default:
- mGLState.getIntegeri_v(target, index, data);
- }
- }
- else
- {
- CastIndexedStateValues(this, nativeType, target, index, numParams, 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)
- {
- mGLState.getInteger64i_v(target, index, data);
- }
- else
- {
- CastIndexedStateValues(this, nativeType, target, index, numParams, 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)
- {
- mGLState.getBooleani_v(target, index, data);
- }
- else
- {
- CastIndexedStateValues(this, nativeType, target, index, numParams, data);
- }
-}
-
-void Context::getBufferParameteriv(BufferBinding target, GLenum pname, GLint *params)
-{
- Buffer *buffer = mGLState.getTargetBuffer(target);
- QueryBufferParameteriv(buffer, pname, params);
-}
-
-void Context::getFramebufferAttachmentParameteriv(GLenum target,
- GLenum attachment,
- GLenum pname,
- GLint *params)
-{
- const Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- QueryFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
-}
-
-void Context::getRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
- Renderbuffer *renderbuffer = mGLState.getCurrentRenderbuffer();
- QueryRenderbufferiv(this, renderbuffer, pname, params);
-}
-
-void Context::getTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
- Texture *texture = getTargetTexture(target);
- QueryTexParameterfv(texture, pname, params);
-}
-
-void Context::getTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
- Texture *texture = getTargetTexture(target);
- QueryTexParameteriv(texture, pname, params);
-}
-
-void Context::getTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-{
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- QueryTexLevelParameteriv(texture, target, level, pname, params);
-}
-
-void Context::getTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-{
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- QueryTexLevelParameterfv(texture, target, level, pname, params);
-}
-
-void Context::texParameterf(GLenum target, GLenum pname, GLfloat param)
-{
- Texture *texture = getTargetTexture(target);
- SetTexParameterf(this, texture, pname, param);
- onTextureChange(texture);
-}
-
-void Context::texParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
- Texture *texture = getTargetTexture(target);
- SetTexParameterfv(this, texture, pname, params);
- onTextureChange(texture);
-}
-
-void Context::texParameteri(GLenum target, GLenum pname, GLint param)
-{
- Texture *texture = getTargetTexture(target);
- SetTexParameteri(this, texture, pname, param);
- onTextureChange(texture);
-}
-
-void Context::texParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
- Texture *texture = getTargetTexture(target);
- SetTexParameteriv(this, texture, pname, params);
- onTextureChange(texture);
-}
-
-void Context::drawArrays(GLenum mode, GLint first, GLsizei count)
-{
- ANGLE_CONTEXT_TRY(prepareForDraw());
- ANGLE_CONTEXT_TRY(mImplementation->drawArrays(this, mode, first, count));
- MarkTransformFeedbackBufferUsage(mGLState.getCurrentTransformFeedback());
-}
-
-void Context::drawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
-{
- ANGLE_CONTEXT_TRY(prepareForDraw());
- ANGLE_CONTEXT_TRY(
- mImplementation->drawArraysInstanced(this, mode, first, count, instanceCount));
- MarkTransformFeedbackBufferUsage(mGLState.getCurrentTransformFeedback());
-}
-
-void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
-{
- ANGLE_CONTEXT_TRY(prepareForDraw());
- ANGLE_CONTEXT_TRY(mImplementation->drawElements(this, mode, count, type, indices));
-}
-
-void Context::drawElementsInstanced(GLenum mode,
- GLsizei count,
- GLenum type,
- const void *indices,
- GLsizei instances)
-{
- ANGLE_CONTEXT_TRY(prepareForDraw());
- ANGLE_CONTEXT_TRY(
- mImplementation->drawElementsInstanced(this, mode, count, type, indices, instances));
-}
-
-void Context::drawRangeElements(GLenum mode,
- GLuint start,
- GLuint end,
- GLsizei count,
- GLenum type,
- const void *indices)
-{
- ANGLE_CONTEXT_TRY(prepareForDraw());
- ANGLE_CONTEXT_TRY(
- mImplementation->drawRangeElements(this, mode, start, end, count, type, indices));
-}
-
-void Context::drawArraysIndirect(GLenum mode, const void *indirect)
-{
- ANGLE_CONTEXT_TRY(prepareForDraw());
- ANGLE_CONTEXT_TRY(mImplementation->drawArraysIndirect(this, mode, indirect));
-}
-
-void Context::drawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
-{
- ANGLE_CONTEXT_TRY(prepareForDraw());
- ANGLE_CONTEXT_TRY(mImplementation->drawElementsIndirect(this, mode, type, indirect));
-}
-
-void Context::flush()
-{
- handleError(mImplementation->flush(this));
-}
-
-void Context::finish()
-{
- handleError(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);
- mImplementation->pushGroupMarker(length, marker);
-}
-
-void Context::popGroupMarker()
-{
- ASSERT(mImplementation);
- mImplementation->popGroupMarker();
-}
-
-void Context::bindUniformLocation(GLuint program, GLint location, const GLchar *name)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
-
- programObject->bindUniformLocation(location, name);
-}
-
-void Context::setCoverageModulation(GLenum components)
-{
- mGLState.setCoverageModulation(components);
-}
-
-void Context::loadPathRenderingMatrix(GLenum matrixMode, const GLfloat *matrix)
-{
- mGLState.loadPathRenderingMatrix(matrixMode, matrix);
-}
-
-void Context::loadPathRenderingIdentityMatrix(GLenum matrixMode)
-{
- GLfloat I[16];
- angle::Matrix<GLfloat>::setToIdentity(I);
-
- mGLState.loadPathRenderingMatrix(matrixMode, I);
-}
-
-void Context::stencilFillPath(GLuint path, GLenum fillMode, GLuint mask)
-{
- const auto *pathObj = mState.mPaths->getPath(path);
- if (!pathObj)
- return;
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilFillPath(pathObj, fillMode, mask);
-}
-
-void Context::stencilStrokePath(GLuint path, GLint reference, GLuint mask)
-{
- const auto *pathObj = mState.mPaths->getPath(path);
- if (!pathObj)
- return;
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilStrokePath(pathObj, reference, mask);
-}
-
-void Context::coverFillPath(GLuint path, GLenum coverMode)
-{
- const auto *pathObj = mState.mPaths->getPath(path);
- if (!pathObj)
- return;
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->coverFillPath(pathObj, coverMode);
-}
-
-void Context::coverStrokePath(GLuint path, GLenum coverMode)
-{
- const auto *pathObj = mState.mPaths->getPath(path);
- if (!pathObj)
- return;
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->coverStrokePath(pathObj, coverMode);
-}
-
-void Context::stencilThenCoverFillPath(GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode)
-{
- const auto *pathObj = mState.mPaths->getPath(path);
- if (!pathObj)
- return;
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilThenCoverFillPath(pathObj, fillMode, mask, coverMode);
-}
-
-void Context::stencilThenCoverStrokePath(GLuint path,
- GLint reference,
- GLuint mask,
- GLenum coverMode)
-{
- const auto *pathObj = mState.mPaths->getPath(path);
- if (!pathObj)
- return;
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilThenCoverStrokePath(pathObj, reference, mask, coverMode);
-}
-
-void Context::coverFillPathInstanced(GLsizei numPaths,
- GLenum pathNameType,
- const void *paths,
- GLuint pathBase,
- GLenum coverMode,
- GLenum transformType,
- const GLfloat *transformValues)
-{
- const auto &pathObjects = GatherPaths(*mState.mPaths, numPaths, pathNameType, paths, pathBase);
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->coverFillPathInstanced(pathObjects, coverMode, transformType, transformValues);
-}
-
-void Context::coverStrokePathInstanced(GLsizei numPaths,
- GLenum pathNameType,
- const void *paths,
- GLuint pathBase,
- GLenum coverMode,
- GLenum transformType,
- const GLfloat *transformValues)
-{
- const auto &pathObjects = GatherPaths(*mState.mPaths, numPaths, pathNameType, paths, pathBase);
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->coverStrokePathInstanced(pathObjects, coverMode, transformType,
- transformValues);
-}
-
-void Context::stencilFillPathInstanced(GLsizei numPaths,
- GLenum pathNameType,
- const void *paths,
- GLuint pathBase,
- GLenum fillMode,
- GLuint mask,
- GLenum transformType,
- const GLfloat *transformValues)
-{
- const auto &pathObjects = GatherPaths(*mState.mPaths, numPaths, pathNameType, paths, pathBase);
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilFillPathInstanced(pathObjects, fillMode, mask, transformType,
- transformValues);
-}
-
-void Context::stencilStrokePathInstanced(GLsizei numPaths,
- GLenum pathNameType,
- const void *paths,
- GLuint pathBase,
- GLint reference,
- GLuint mask,
- GLenum transformType,
- const GLfloat *transformValues)
-{
- const auto &pathObjects = GatherPaths(*mState.mPaths, numPaths, pathNameType, paths, pathBase);
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilStrokePathInstanced(pathObjects, reference, mask, transformType,
- transformValues);
-}
-
-void Context::stencilThenCoverFillPathInstanced(GLsizei numPaths,
- GLenum pathNameType,
- const void *paths,
- GLuint pathBase,
- GLenum fillMode,
- GLuint mask,
- GLenum coverMode,
- GLenum transformType,
- const GLfloat *transformValues)
-{
- const auto &pathObjects = GatherPaths(*mState.mPaths, numPaths, pathNameType, paths, pathBase);
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilThenCoverFillPathInstanced(pathObjects, coverMode, fillMode, mask,
- transformType, transformValues);
-}
-
-void Context::stencilThenCoverStrokePathInstanced(GLsizei numPaths,
- GLenum pathNameType,
- const void *paths,
- GLuint pathBase,
- GLint reference,
- GLuint mask,
- GLenum coverMode,
- GLenum transformType,
- const GLfloat *transformValues)
-{
- const auto &pathObjects = GatherPaths(*mState.mPaths, numPaths, pathNameType, paths, pathBase);
-
- // TODO(svaisanen@nvidia.com): maybe sync only state required for path rendering?
- syncRendererState();
-
- mImplementation->stencilThenCoverStrokePathInstanced(pathObjects, coverMode, reference, mask,
- transformType, transformValues);
-}
-
-void Context::bindFragmentInputLocation(GLuint program, GLint location, const GLchar *name)
-{
- auto *programObject = getProgram(program);
-
- programObject->bindFragmentInputLocation(location, name);
-}
-
-void Context::programPathFragmentInputGen(GLuint program,
- GLint location,
- GLenum genMode,
- GLint components,
- const GLfloat *coeffs)
-{
- auto *programObject = getProgram(program);
-
- programObject->pathFragmentInputGen(this, location, genMode, components, coeffs);
-}
-
-GLuint Context::getProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
-{
- const auto *programObject = getProgram(program);
- return QueryProgramResourceIndex(programObject, programInterface, name);
-}
-
-void Context::getProgramResourceName(GLuint program,
- GLenum programInterface,
- GLuint index,
- GLsizei bufSize,
- GLsizei *length,
- GLchar *name)
-{
- const auto *programObject = getProgram(program);
- QueryProgramResourceName(programObject, programInterface, index, bufSize, length, name);
-}
-
-GLint Context::getProgramResourceLocation(GLuint program,
- GLenum programInterface,
- const GLchar *name)
-{
- const auto *programObject = getProgram(program);
- return QueryProgramResourceLocation(programObject, programInterface, name);
-}
-
-void Context::getProgramResourceiv(GLuint program,
- GLenum programInterface,
- GLuint index,
- GLsizei propCount,
- const GLenum *props,
- GLsizei bufSize,
- GLsizei *length,
- GLint *params)
-{
- const auto *programObject = getProgram(program);
- QueryProgramResourceiv(programObject, programInterface, index, propCount, props, bufSize,
- length, params);
-}
-
-void Context::getProgramInterfaceiv(GLuint program,
- GLenum programInterface,
- GLenum pname,
- GLint *params)
-{
- const auto *programObject = getProgram(program);
- QueryProgramInterfaceiv(programObject, programInterface, pname, params);
-}
-
-void Context::handleError(const Error &error)
-{
- if (error.isError())
- {
- GLenum code = error.getCode();
- mErrors.insert(code);
- if (code == GL_OUT_OF_MEMORY && getWorkarounds().loseContextOnOutOfMemory)
- {
- markContextLost();
- }
-
- ASSERT(!error.getMessage().empty());
- mGLState.getDebug().insertMessage(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, error.getID(),
- GL_DEBUG_SEVERITY_HIGH, error.getMessage());
- }
-}
-
-// 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;
- }
-}
-
-// 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;
- mContextLostForced = true;
- }
- mContextLost = true;
-}
-
-bool Context::isContextLost()
-{
- return mContextLost;
-}
-
-GLenum Context::getResetStatus()
-{
- // 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() != GL_NO_ERROR)
- {
- 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 == GL_NO_ERROR);
- mResetStatus = mImplementation->getResetStatus();
-
- if (mResetStatus != GL_NO_ERROR)
- {
- mContextLost = true;
- }
- }
- else if (!mContextLostForced && mResetStatus != GL_NO_ERROR)
- {
- // 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 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 mClientType;
-}
-
-EGLenum Context::getRenderBuffer() const
-{
- const Framebuffer *framebuffer = mState.mFramebuffers->getFramebuffer(0);
- if (framebuffer == nullptr)
- {
- return EGL_NONE;
- }
-
- const FramebufferAttachment *backAttachment = framebuffer->getAttachment(GL_BACK);
- ASSERT(backAttachment != nullptr);
- return backAttachment->getSurface()->getRenderBuffer();
-}
-
-VertexArray *Context::checkVertexArrayAllocation(GLuint vertexArrayHandle)
-{
- // Only called after a prior call to Gen.
- VertexArray *vertexArray = getVertexArray(vertexArrayHandle);
- if (!vertexArray)
- {
- vertexArray = new VertexArray(mImplementation.get(), vertexArrayHandle,
- mCaps.maxVertexAttributes, mCaps.maxVertexAttribBindings);
-
- mVertexArrayMap.assign(vertexArrayHandle, vertexArray);
- }
-
- return vertexArray;
-}
-
-TransformFeedback *Context::checkTransformFeedbackAllocation(GLuint transformFeedbackHandle)
-{
- // Only called after a prior call to Gen.
- TransformFeedback *transformFeedback = getTransformFeedback(transformFeedbackHandle);
- if (!transformFeedback)
- {
- transformFeedback =
- new TransformFeedback(mImplementation.get(), transformFeedbackHandle, mCaps);
- transformFeedback->addRef();
- mTransformFeedbackMap.assign(transformFeedbackHandle, transformFeedback);
- }
-
- return transformFeedback;
-}
-
-bool Context::isVertexArrayGenerated(GLuint vertexArray)
-{
- ASSERT(mVertexArrayMap.contains(0));
- return mVertexArrayMap.contains(vertexArray);
-}
-
-bool Context::isTransformFeedbackGenerated(GLuint transformFeedback)
-{
- ASSERT(mTransformFeedbackMap.contains(0));
- return mTransformFeedbackMap.contains(transformFeedback);
-}
-
-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.
- mGLState.detachTexture(this, mZeroTextures, texture);
-}
-
-void Context::detachBuffer(GLuint 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
- mGLState.detachBuffer(this, 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 (mGLState.removeReadFramebufferBinding(framebuffer) && framebuffer != 0)
- {
- bindReadFramebuffer(0);
- }
-
- if (mGLState.removeDrawFramebufferBinding(framebuffer) && framebuffer != 0)
- {
- bindDrawFramebuffer(0);
- }
-}
-
-void Context::detachRenderbuffer(GLuint renderbuffer)
-{
- mGLState.detachRenderbuffer(this, 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 (mGLState.removeVertexArrayBinding(vertexArray))
- {
- bindVertexArray(0);
- }
-}
-
-void Context::detachTransformFeedback(GLuint 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 (mGLState.removeTransformFeedbackBinding(this, transformFeedback))
- {
- bindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
- }
-}
-
-void Context::detachSampler(GLuint sampler)
-{
- mGLState.detachSampler(this, sampler);
-}
-
-void Context::detachProgramPipeline(GLuint pipeline)
-{
- mGLState.detachProgramPipeline(this, pipeline);
-}
-
-void Context::vertexAttribDivisor(GLuint index, GLuint divisor)
-{
- mGLState.setVertexAttribDivisor(this, index, divisor);
-}
-
-void Context::samplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
- Sampler *samplerObject =
- mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
- SetSamplerParameteri(samplerObject, pname, param);
- mGLState.setObjectDirty(GL_SAMPLER);
-}
-
-void Context::samplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
-{
- Sampler *samplerObject =
- mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
- SetSamplerParameteriv(samplerObject, pname, param);
- mGLState.setObjectDirty(GL_SAMPLER);
-}
-
-void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
- Sampler *samplerObject =
- mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
- SetSamplerParameterf(samplerObject, pname, param);
- mGLState.setObjectDirty(GL_SAMPLER);
-}
-
-void Context::samplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
-{
- Sampler *samplerObject =
- mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
- SetSamplerParameterfv(samplerObject, pname, param);
- mGLState.setObjectDirty(GL_SAMPLER);
-}
-
-void Context::getSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
-{
- const Sampler *samplerObject =
- mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
- QuerySamplerParameteriv(samplerObject, pname, params);
- mGLState.setObjectDirty(GL_SAMPLER);
-}
-
-void Context::getSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
-{
- const Sampler *samplerObject =
- mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
- QuerySamplerParameterfv(samplerObject, pname, params);
- mGLState.setObjectDirty(GL_SAMPLER);
-}
-
-void Context::programParameteri(GLuint program, GLenum pname, GLint value)
-{
- gl::Program *programObject = getProgram(program);
- SetProgramParameteri(programObject, pname, value);
-}
-
-void Context::initRendererString()
-{
- std::ostringstream rendererString;
- rendererString << "ANGLE (";
- rendererString << mImplementation->getRendererDescription();
- rendererString << ")";
-
- mRendererString = MakeStaticString(rendererString.str());
-}
-
-void Context::initVersionStrings()
-{
- const Version &clientVersion = getClientVersion();
-
- std::ostringstream versionString;
- versionString << "OpenGL ES " << clientVersion.major << "." << clientVersion.minor << " (ANGLE "
- << ANGLE_VERSION_STRING << ")";
- mVersionString = MakeStaticString(versionString.str());
-
- std::ostringstream shadingLanguageVersionString;
- shadingLanguageVersionString << "OpenGL ES GLSL ES "
- << (clientVersion.major == 2 ? 1 : clientVersion.major) << "."
- << clientVersion.minor << "0 (ANGLE " << ANGLE_VERSION_STRING
- << ")";
- mShadingLanguageString = MakeStaticString(shadingLanguageVersionString.str());
-}
-
-void Context::initExtensionStrings()
-{
- auto mergeExtensionStrings = [](const std::vector<const char *> &strings) {
- std::ostringstream combinedStringStream;
- std::copy(strings.begin(), strings.end(),
- std::ostream_iterator<const char *>(combinedStringStream, " "));
- return MakeStaticString(combinedStringStream.str());
- };
-
- mExtensionStrings.clear();
- for (const auto &extensionString : mExtensions.getStrings())
- {
- mExtensionStrings.push_back(MakeStaticString(extensionString));
- }
- mExtensionString = mergeExtensionStrings(mExtensionStrings);
-
- const gl::Extensions &nativeExtensions = mImplementation->getNativeExtensions();
-
- mRequestableExtensionStrings.clear();
- for (const auto &extensionInfo : GetExtensionInfoMap())
- {
- if (extensionInfo.second.Requestable &&
- !(mExtensions.*(extensionInfo.second.ExtensionsMember)) &&
- nativeExtensions.*(extensionInfo.second.ExtensionsMember))
- {
- mRequestableExtensionStrings.push_back(MakeStaticString(extensionInfo.first));
- }
- }
- mRequestableExtensionString = mergeExtensionStrings(mRequestableExtensionStrings);
-}
-
-const GLubyte *Context::getString(GLenum name) const
-{
- switch (name)
- {
- case GL_VENDOR:
- return reinterpret_cast<const GLubyte *>("Google Inc.");
-
- case GL_RENDERER:
- return reinterpret_cast<const GLubyte *>(mRendererString);
-
- case GL_VERSION:
- return reinterpret_cast<const GLubyte *>(mVersionString);
-
- case GL_SHADING_LANGUAGE_VERSION:
- return reinterpret_cast<const GLubyte *>(mShadingLanguageString);
-
- case GL_EXTENSIONS:
- return reinterpret_cast<const GLubyte *>(mExtensionString);
-
- case GL_REQUESTABLE_EXTENSIONS_ANGLE:
- return reinterpret_cast<const GLubyte *>(mRequestableExtensionString);
-
- default:
- UNREACHABLE();
- return nullptr;
- }
-}
-
-const GLubyte *Context::getStringi(GLenum name, GLuint index) const
-{
- switch (name)
- {
- case GL_EXTENSIONS:
- return reinterpret_cast<const GLubyte *>(mExtensionStrings[index]);
-
- case GL_REQUESTABLE_EXTENSIONS_ANGLE:
- return reinterpret_cast<const GLubyte *>(mRequestableExtensionStrings[index]);
-
- default:
- UNREACHABLE();
- return nullptr;
- }
-}
-
-size_t Context::getExtensionStringCount() const
-{
- return mExtensionStrings.size();
-}
-
-bool Context::isExtensionRequestable(const char *name)
-{
- const ExtensionInfoMap &extensionInfos = GetExtensionInfoMap();
- auto extension = extensionInfos.find(name);
-
- const Extensions &nativeExtensions = mImplementation->getNativeExtensions();
- return extension != extensionInfos.end() && extension->second.Requestable &&
- nativeExtensions.*(extension->second.ExtensionsMember);
-}
-
-void Context::requestExtension(const char *name)
-{
- const ExtensionInfoMap &extensionInfos = GetExtensionInfoMap();
- ASSERT(extensionInfos.find(name) != extensionInfos.end());
- const auto &extension = extensionInfos.at(name);
- ASSERT(extension.Requestable);
- ASSERT(mImplementation->getNativeExtensions().*(extension.ExtensionsMember));
-
- if (mExtensions.*(extension.ExtensionsMember))
- {
- // Extension already enabled
- return;
- }
-
- mExtensions.*(extension.ExtensionsMember) = true;
- updateCaps();
- initExtensionStrings();
-
- // Release the shader compiler so it will be re-created with the requested extensions enabled.
- releaseShaderCompiler();
-
- // Invalidate all textures and framebuffer. Some extensions make new formats renderable or
- // sampleable.
- mState.mTextures->signalAllTexturesDirty();
- for (auto &zeroTexture : mZeroTextures)
- {
- zeroTexture.second->signalDirty(InitState::Initialized);
- }
-
- mState.mFramebuffers->invalidateFramebufferComplenessCache();
-}
-
-size_t Context::getRequestableExtensionStringCount() const
-{
- return mRequestableExtensionStrings.size();
-}
-
-void Context::beginTransformFeedback(GLenum primitiveMode)
-{
- TransformFeedback *transformFeedback = mGLState.getCurrentTransformFeedback();
- ASSERT(transformFeedback != nullptr);
- ASSERT(!transformFeedback->isPaused());
-
- transformFeedback->begin(this, primitiveMode, mGLState.getProgram());
-}
-
-bool Context::hasActiveTransformFeedback(GLuint program) const
-{
- for (auto pair : mTransformFeedbackMap)
- {
- if (pair.second != nullptr && pair.second->hasBoundProgram(program))
- {
- return true;
- }
- }
- return false;
-}
-
-void Context::initCaps(const egl::DisplayExtensions &displayExtensions, bool robustResourceInit)
-{
- mCaps = mImplementation->getNativeCaps();
-
- mExtensions = mImplementation->getNativeExtensions();
-
- mLimitations = mImplementation->getNativeLimitations();
-
- if (getClientVersion() < Version(3, 0))
- {
- // Disable ES3+ extensions
- mExtensions.colorBufferFloat = false;
- mExtensions.eglImageExternalEssl3 = false;
- mExtensions.textureNorm16 = false;
- mExtensions.multiview = false;
- mExtensions.maxViews = 1u;
- }
-
- if (getClientVersion() < ES_3_1)
- {
- // Disable ES3.1+ extensions
- mExtensions.geometryShader = false;
- }
-
- if (getClientVersion() > Version(2, 0))
- {
- // FIXME(geofflang): Don't support EXT_sRGB in non-ES2 contexts
- // mExtensions.sRGB = false;
- }
-
- // Some extensions are always available because they are implemented in the GL layer.
- mExtensions.bindUniformLocation = true;
- mExtensions.vertexArrayObject = true;
- mExtensions.bindGeneratesResource = true;
- mExtensions.clientArrays = true;
- mExtensions.requestExtension = true;
-
- // Enable the no error extension if the context was created with the flag.
- mExtensions.noError = mSkipValidation;
-
- // Enable surfaceless to advertise we'll have the correct behavior when there is no default FBO
- mExtensions.surfacelessContext = displayExtensions.surfacelessContext;
-
- // Explicitly enable GL_KHR_debug
- mExtensions.debug = true;
- mExtensions.maxDebugMessageLength = 1024;
- mExtensions.maxDebugLoggedMessages = 1024;
- mExtensions.maxDebugGroupStackDepth = 1024;
- mExtensions.maxLabelLength = 1024;
-
- // Explicitly enable GL_ANGLE_robust_client_memory
- mExtensions.robustClientMemory = true;
-
- // Determine robust resource init availability from EGL.
- mExtensions.robustResourceInitialization = robustResourceInit;
-
- // mExtensions.robustBufferAccessBehavior is true only if robust access is true and the backend
- // supports it.
- mExtensions.robustBufferAccessBehavior =
- mRobustAccess && mExtensions.robustBufferAccessBehavior;
-
- // Enable the cache control query unconditionally.
- mExtensions.programCacheControl = true;
-
- // Apply implementation limits
- LimitCap(&mCaps.maxVertexAttributes, MAX_VERTEX_ATTRIBS);
-
- if (getClientVersion() < ES_3_1)
- {
- mCaps.maxVertexAttribBindings = mCaps.maxVertexAttributes;
- }
- else
- {
- LimitCap(&mCaps.maxVertexAttribBindings, MAX_VERTEX_ATTRIB_BINDINGS);
- }
-
- LimitCap(&mCaps.maxVertexUniformBlocks, IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS);
- LimitCap(&mCaps.maxVertexOutputComponents, IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
- LimitCap(&mCaps.maxFragmentInputComponents, IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
-
- // Limit textures as well, so we can use fast bitsets with texture bindings.
- LimitCap(&mCaps.maxCombinedTextureImageUnits, IMPLEMENTATION_MAX_ACTIVE_TEXTURES);
- LimitCap(&mCaps.maxVertexTextureImageUnits, IMPLEMENTATION_MAX_ACTIVE_TEXTURES / 2);
- LimitCap(&mCaps.maxTextureImageUnits, IMPLEMENTATION_MAX_ACTIVE_TEXTURES / 2);
-
- mCaps.maxSampleMaskWords = std::min<GLuint>(mCaps.maxSampleMaskWords, MAX_SAMPLE_MASK_WORDS);
-
- // WebGL compatibility
- mExtensions.webglCompatibility = mWebGLContext;
- for (const auto &extensionInfo : GetExtensionInfoMap())
- {
- // If this context is for WebGL, disable all enableable extensions
- if (mWebGLContext && extensionInfo.second.Requestable)
- {
- mExtensions.*(extensionInfo.second.ExtensionsMember) = false;
- }
- }
-
- // Generate texture caps
- updateCaps();
-}
-
-void Context::updateCaps()
-{
- mCaps.compressedTextureFormats.clear();
- mTextureCaps.clear();
-
- for (GLenum sizedInternalFormat : GetAllSizedInternalFormats())
- {
- TextureCaps formatCaps = mImplementation->getNativeTextureCaps().get(sizedInternalFormat);
- const InternalFormat &formatInfo = GetSizedInternalFormatInfo(sizedInternalFormat);
-
- // Update the format caps based on the client version and extensions.
- // Caps are AND'd with the renderer caps because some core formats are still unsupported in
- // ES3.
- formatCaps.texturable =
- formatCaps.texturable && formatInfo.textureSupport(getClientVersion(), mExtensions);
- formatCaps.renderable =
- formatCaps.renderable && formatInfo.renderSupport(getClientVersion(), mExtensions);
- formatCaps.filterable =
- formatCaps.filterable && formatInfo.filterSupport(getClientVersion(), mExtensions);
-
- // OpenGL ES does not support multisampling with non-rendererable formats
- // OpenGL ES 3.0 or prior does not support multisampling with integer formats
- if (!formatCaps.renderable ||
- (getClientVersion() < ES_3_1 &&
- (formatInfo.componentType == GL_INT || formatInfo.componentType == GL_UNSIGNED_INT)))
- {
- formatCaps.sampleCounts.clear();
- }
- else
- {
- // We may have limited the max samples for some required renderbuffer formats due to
- // non-conformant formats. In this case MAX_SAMPLES needs to be lowered accordingly.
- GLuint formatMaxSamples = formatCaps.getMaxSamples();
-
- // GLES 3.0.5 section 4.4.2.2: "Implementations must support creation of renderbuffers
- // in these required formats with up to the value of MAX_SAMPLES multisamples, with the
- // exception of signed and unsigned integer formats."
- if (formatInfo.componentType != GL_INT && formatInfo.componentType != GL_UNSIGNED_INT &&
- formatInfo.isRequiredRenderbufferFormat(getClientVersion()))
- {
- ASSERT(getClientVersion() < ES_3_0 || formatMaxSamples >= 4);
- mCaps.maxSamples = std::min(mCaps.maxSamples, formatMaxSamples);
- }
-
- // Handle GLES 3.1 MAX_*_SAMPLES values similarly to MAX_SAMPLES.
- if (getClientVersion() >= ES_3_1)
- {
- // GLES 3.1 section 9.2.5: "Implementations must support creation of renderbuffers
- // in these required formats with up to the value of MAX_SAMPLES multisamples, with
- // the exception that the signed and unsigned integer formats are required only to
- // support creation of renderbuffers with up to the value of MAX_INTEGER_SAMPLES
- // multisamples, which must be at least one."
- if (formatInfo.componentType == GL_INT ||
- formatInfo.componentType == GL_UNSIGNED_INT)
- {
- mCaps.maxIntegerSamples = std::min(mCaps.maxIntegerSamples, formatMaxSamples);
- }
-
- // GLES 3.1 section 19.3.1.
- if (formatCaps.texturable)
- {
- if (formatInfo.depthBits > 0)
- {
- mCaps.maxDepthTextureSamples =
- std::min(mCaps.maxDepthTextureSamples, formatMaxSamples);
- }
- else if (formatInfo.redBits > 0)
- {
- mCaps.maxColorTextureSamples =
- std::min(mCaps.maxColorTextureSamples, formatMaxSamples);
- }
- }
- }
- }
-
- if (formatCaps.texturable && formatInfo.compressed)
- {
- mCaps.compressedTextureFormats.push_back(sizedInternalFormat);
- }
-
- mTextureCaps.insert(sizedInternalFormat, formatCaps);
- }
-
- // If program binary is disabled, blank out the memory cache pointer.
- if (!mImplementation->getNativeExtensions().getProgramBinary)
- {
- mMemoryProgramCache = nullptr;
- }
-}
-
-void Context::initWorkarounds()
-{
- // Apply back-end workarounds.
- mImplementation->applyNativeWorkarounds(&mWorkarounds);
-
- // Lose the context upon out of memory error if the application is
- // expecting to watch for those events.
- mWorkarounds.loseContextOnOutOfMemory = (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT);
-}
-
-Error Context::prepareForDraw()
-{
- syncRendererState();
-
- if (isRobustResourceInitEnabled())
- {
- ANGLE_TRY(mGLState.clearUnclearedActiveTextures(this));
- ANGLE_TRY(mGLState.getDrawFramebuffer()->ensureDrawAttachmentsInitialized(this));
- }
-
- return NoError();
-}
-
-void Context::syncRendererState()
-{
- mGLState.syncDirtyObjects(this);
- const State::DirtyBits &dirtyBits = mGLState.getDirtyBits();
- mImplementation->syncState(this, dirtyBits);
- mGLState.clearDirtyBits();
-}
-
-void Context::syncRendererState(const State::DirtyBits &bitMask,
- const State::DirtyObjects &objectMask)
-{
- mGLState.syncDirtyObjects(this, objectMask);
- const State::DirtyBits &dirtyBits = (mGLState.getDirtyBits() & bitMask);
- mImplementation->syncState(this, dirtyBits);
- mGLState.clearDirtyBits(dirtyBits);
-}
-
-void Context::blitFramebuffer(GLint srcX0,
- GLint srcY0,
- GLint srcX1,
- GLint srcY1,
- GLint dstX0,
- GLint dstY0,
- GLint dstX1,
- GLint dstY1,
- GLbitfield mask,
- GLenum filter)
-{
- Framebuffer *drawFramebuffer = mGLState.getDrawFramebuffer();
- ASSERT(drawFramebuffer);
-
- Rectangle srcArea(srcX0, srcY0, srcX1 - srcX0, srcY1 - srcY0);
- Rectangle dstArea(dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0);
-
- syncStateForBlit();
-
- handleError(drawFramebuffer->blit(this, srcArea, dstArea, mask, filter));
-}
-
-void Context::clear(GLbitfield mask)
-{
- syncStateForClear();
- handleError(mGLState.getDrawFramebuffer()->clear(this, mask));
-}
-
-void Context::clearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *values)
-{
- syncStateForClear();
- handleError(mGLState.getDrawFramebuffer()->clearBufferfv(this, buffer, drawbuffer, values));
-}
-
-void Context::clearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *values)
-{
- syncStateForClear();
- handleError(mGLState.getDrawFramebuffer()->clearBufferuiv(this, buffer, drawbuffer, values));
-}
-
-void Context::clearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *values)
-{
- syncStateForClear();
- handleError(mGLState.getDrawFramebuffer()->clearBufferiv(this, buffer, drawbuffer, values));
-}
-
-void Context::clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
- Framebuffer *framebufferObject = mGLState.getDrawFramebuffer();
- ASSERT(framebufferObject);
-
- // If a buffer is not present, the clear has no effect
- if (framebufferObject->getDepthbuffer() == nullptr &&
- framebufferObject->getStencilbuffer() == nullptr)
- {
- return;
- }
-
- syncStateForClear();
- handleError(framebufferObject->clearBufferfi(this, buffer, drawbuffer, depth, stencil));
-}
-
-void Context::readPixels(GLint x,
- GLint y,
- GLsizei width,
- GLsizei height,
- GLenum format,
- GLenum type,
- void *pixels)
-{
- if (width == 0 || height == 0)
- {
- return;
- }
-
- syncStateForReadPixels();
-
- Framebuffer *readFBO = mGLState.getReadFramebuffer();
- ASSERT(readFBO);
-
- Rectangle area(x, y, width, height);
- handleError(readFBO->readPixels(this, area, format, type, pixels));
-}
-
-void Context::copyTexImage2D(GLenum target,
- GLint level,
- GLenum internalformat,
- GLint x,
- GLint y,
- GLsizei width,
- GLsizei height,
- GLint border)
-{
- // Only sync the read FBO
- mGLState.syncDirtyObject(this, GL_READ_FRAMEBUFFER);
-
- Rectangle sourceArea(x, y, width, height);
-
- Framebuffer *framebuffer = mGLState.getReadFramebuffer();
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- handleError(texture->copyImage(this, target, level, sourceArea, internalformat, framebuffer));
-}
-
-void Context::copyTexSubImage2D(GLenum target,
- GLint level,
- GLint xoffset,
- GLint yoffset,
- GLint x,
- GLint y,
- GLsizei width,
- GLsizei height)
-{
- if (width == 0 || height == 0)
- {
- return;
- }
-
- // Only sync the read FBO
- mGLState.syncDirtyObject(this, GL_READ_FRAMEBUFFER);
-
- Offset destOffset(xoffset, yoffset, 0);
- Rectangle sourceArea(x, y, width, height);
-
- Framebuffer *framebuffer = mGLState.getReadFramebuffer();
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- handleError(texture->copySubImage(this, target, level, destOffset, sourceArea, framebuffer));
-}
-
-void Context::copyTexSubImage3D(GLenum target,
- GLint level,
- GLint xoffset,
- GLint yoffset,
- GLint zoffset,
- GLint x,
- GLint y,
- GLsizei width,
- GLsizei height)
-{
- if (width == 0 || height == 0)
- {
- return;
- }
-
- // Only sync the read FBO
- mGLState.syncDirtyObject(this, GL_READ_FRAMEBUFFER);
-
- Offset destOffset(xoffset, yoffset, zoffset);
- Rectangle sourceArea(x, y, width, height);
-
- Framebuffer *framebuffer = mGLState.getReadFramebuffer();
- Texture *texture = getTargetTexture(target);
- handleError(texture->copySubImage(this, target, level, destOffset, sourceArea, framebuffer));
-}
-
-void Context::framebufferTexture2D(GLenum target,
- GLenum attachment,
- GLenum textarget,
- GLuint texture,
- GLint level)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- if (texture != 0)
- {
- Texture *textureObj = getTexture(texture);
-
- ImageIndex index = ImageIndex::MakeInvalid();
-
- if (textarget == GL_TEXTURE_2D)
- {
- index = ImageIndex::Make2D(level);
- }
- else if (textarget == GL_TEXTURE_RECTANGLE_ANGLE)
- {
- index = ImageIndex::MakeRectangle(level);
- }
- else if (textarget == GL_TEXTURE_2D_MULTISAMPLE)
- {
- ASSERT(level == 0);
- index = ImageIndex::Make2DMultisample();
- }
- else
- {
- ASSERT(IsCubeMapTextureTarget(textarget));
- index = ImageIndex::MakeCube(textarget, level);
- }
-
- framebuffer->setAttachment(this, GL_TEXTURE, attachment, index, textureObj);
- }
- else
- {
- framebuffer->resetAttachment(this, attachment);
- }
-
- mGLState.setObjectDirty(target);
-}
-
-void Context::framebufferRenderbuffer(GLenum target,
- GLenum attachment,
- GLenum renderbuffertarget,
- GLuint renderbuffer)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- if (renderbuffer != 0)
- {
- Renderbuffer *renderbufferObject = getRenderbuffer(renderbuffer);
-
- framebuffer->setAttachment(this, GL_RENDERBUFFER, attachment, gl::ImageIndex::MakeInvalid(),
- renderbufferObject);
- }
- else
- {
- framebuffer->resetAttachment(this, attachment);
- }
-
- mGLState.setObjectDirty(target);
-}
-
-void Context::framebufferTextureLayer(GLenum target,
- GLenum attachment,
- GLuint texture,
- GLint level,
- GLint layer)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- if (texture != 0)
- {
- Texture *textureObject = getTexture(texture);
-
- ImageIndex index = ImageIndex::MakeInvalid();
-
- if (textureObject->getTarget() == GL_TEXTURE_3D)
- {
- index = ImageIndex::Make3D(level, layer);
- }
- else
- {
- ASSERT(textureObject->getTarget() == GL_TEXTURE_2D_ARRAY);
- index = ImageIndex::Make2DArray(level, layer);
- }
-
- framebuffer->setAttachment(this, GL_TEXTURE, attachment, index, textureObject);
- }
- else
- {
- framebuffer->resetAttachment(this, attachment);
- }
-
- mGLState.setObjectDirty(target);
-}
-
-void Context::framebufferTextureMultiviewLayeredANGLE(GLenum target,
- GLenum attachment,
- GLuint texture,
- GLint level,
- GLint baseViewIndex,
- GLsizei numViews)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- if (texture != 0)
- {
- Texture *textureObj = getTexture(texture);
-
- ImageIndex index = ImageIndex::Make2DArrayRange(level, baseViewIndex, numViews);
- framebuffer->setAttachmentMultiviewLayered(this, GL_TEXTURE, attachment, index, textureObj,
- numViews, baseViewIndex);
- }
- else
- {
- framebuffer->resetAttachment(this, attachment);
- }
-
- mGLState.setObjectDirty(target);
-}
-
-void Context::framebufferTextureMultiviewSideBySideANGLE(GLenum target,
- GLenum attachment,
- GLuint texture,
- GLint level,
- GLsizei numViews,
- const GLint *viewportOffsets)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- if (texture != 0)
- {
- Texture *textureObj = getTexture(texture);
-
- ImageIndex index = ImageIndex::Make2D(level);
- framebuffer->setAttachmentMultiviewSideBySide(this, GL_TEXTURE, attachment, index,
- textureObj, numViews, viewportOffsets);
- }
- else
- {
- framebuffer->resetAttachment(this, attachment);
- }
-
- mGLState.setObjectDirty(target);
-}
-
-void Context::drawBuffers(GLsizei n, const GLenum *bufs)
-{
- Framebuffer *framebuffer = mGLState.getDrawFramebuffer();
- ASSERT(framebuffer);
- framebuffer->setDrawBuffers(n, bufs);
- mGLState.setObjectDirty(GL_DRAW_FRAMEBUFFER);
-}
-
-void Context::readBuffer(GLenum mode)
-{
- Framebuffer *readFBO = mGLState.getReadFramebuffer();
- readFBO->setReadBuffer(mode);
- mGLState.setObjectDirty(GL_READ_FRAMEBUFFER);
-}
-
-void Context::discardFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
- // Only sync the FBO
- mGLState.syncDirtyObject(this, target);
-
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- // The specification isn't clear what should be done when the framebuffer isn't complete.
- // We leave it up to the framebuffer implementation to decide what to do.
- handleError(framebuffer->discard(this, numAttachments, attachments));
-}
-
-void Context::invalidateFramebuffer(GLenum target,
- GLsizei numAttachments,
- const GLenum *attachments)
-{
- // Only sync the FBO
- mGLState.syncDirtyObject(this, target);
-
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- if (framebuffer->checkStatus(this) != GL_FRAMEBUFFER_COMPLETE)
- {
- return;
- }
-
- handleError(framebuffer->invalidate(this, numAttachments, attachments));
-}
-
-void Context::invalidateSubFramebuffer(GLenum target,
- GLsizei numAttachments,
- const GLenum *attachments,
- GLint x,
- GLint y,
- GLsizei width,
- GLsizei height)
-{
- // Only sync the FBO
- mGLState.syncDirtyObject(this, target);
-
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- if (framebuffer->checkStatus(this) != GL_FRAMEBUFFER_COMPLETE)
- {
- return;
- }
-
- Rectangle area(x, y, width, height);
- handleError(framebuffer->invalidateSub(this, numAttachments, attachments, area));
-}
-
-void Context::texImage2D(GLenum target,
- GLint level,
- GLint internalformat,
- GLsizei width,
- GLsizei height,
- GLint border,
- GLenum format,
- GLenum type,
- const void *pixels)
-{
- syncStateForTexImage();
-
- Extents size(width, height, 1);
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- handleError(texture->setImage(this, mGLState.getUnpackState(), target, level, internalformat,
- size, format, type, reinterpret_cast<const uint8_t *>(pixels)));
-}
-
-void Context::texImage3D(GLenum target,
- GLint level,
- GLint internalformat,
- GLsizei width,
- GLsizei height,
- GLsizei depth,
- GLint border,
- GLenum format,
- GLenum type,
- const void *pixels)
-{
- syncStateForTexImage();
-
- Extents size(width, height, depth);
- Texture *texture = getTargetTexture(target);
- handleError(texture->setImage(this, mGLState.getUnpackState(), target, level, internalformat,
- size, format, type, reinterpret_cast<const uint8_t *>(pixels)));
-}
-
-void Context::texSubImage2D(GLenum target,
- GLint level,
- GLint xoffset,
- GLint yoffset,
- GLsizei width,
- GLsizei height,
- GLenum format,
- GLenum type,
- const void *pixels)
-{
- // Zero sized uploads are valid but no-ops
- if (width == 0 || height == 0)
- {
- return;
- }
-
- syncStateForTexImage();
-
- Box area(xoffset, yoffset, 0, width, height, 1);
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- handleError(texture->setSubImage(this, mGLState.getUnpackState(), target, level, area, format,
- type, reinterpret_cast<const uint8_t *>(pixels)));
-}
-
-void Context::texSubImage3D(GLenum target,
- GLint level,
- GLint xoffset,
- GLint yoffset,
- GLint zoffset,
- GLsizei width,
- GLsizei height,
- GLsizei depth,
- GLenum format,
- GLenum type,
- const void *pixels)
-{
- // Zero sized uploads are valid but no-ops
- if (width == 0 || height == 0 || depth == 0)
- {
- return;
- }
-
- syncStateForTexImage();
-
- Box area(xoffset, yoffset, zoffset, width, height, depth);
- Texture *texture = getTargetTexture(target);
- handleError(texture->setSubImage(this, mGLState.getUnpackState(), target, level, area, format,
- type, reinterpret_cast<const uint8_t *>(pixels)));
-}
-
-void Context::compressedTexImage2D(GLenum target,
- GLint level,
- GLenum internalformat,
- GLsizei width,
- GLsizei height,
- GLint border,
- GLsizei imageSize,
- const void *data)
-{
- syncStateForTexImage();
-
- Extents size(width, height, 1);
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- handleError(texture->setCompressedImage(this, mGLState.getUnpackState(), target, level,
- internalformat, size, imageSize,
- reinterpret_cast<const uint8_t *>(data)));
-}
-
-void Context::compressedTexImage3D(GLenum target,
- GLint level,
- GLenum internalformat,
- GLsizei width,
- GLsizei height,
- GLsizei depth,
- GLint border,
- GLsizei imageSize,
- const void *data)
-{
- syncStateForTexImage();
-
- Extents size(width, height, depth);
- Texture *texture = getTargetTexture(target);
- handleError(texture->setCompressedImage(this, mGLState.getUnpackState(), target, level,
- internalformat, size, imageSize,
- reinterpret_cast<const uint8_t *>(data)));
-}
-
-void Context::compressedTexSubImage2D(GLenum target,
- GLint level,
- GLint xoffset,
- GLint yoffset,
- GLsizei width,
- GLsizei height,
- GLenum format,
- GLsizei imageSize,
- const void *data)
-{
- syncStateForTexImage();
-
- Box area(xoffset, yoffset, 0, width, height, 1);
- Texture *texture =
- getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
- handleError(texture->setCompressedSubImage(this, mGLState.getUnpackState(), target, level, area,
- format, imageSize,
- reinterpret_cast<const uint8_t *>(data)));
-}
-
-void Context::compressedTexSubImage3D(GLenum target,
- GLint level,
- GLint xoffset,
- GLint yoffset,
- GLint zoffset,
- GLsizei width,
- GLsizei height,
- GLsizei depth,
- GLenum format,
- GLsizei imageSize,
- const void *data)
-{
- // Zero sized uploads are valid but no-ops
- if (width == 0 || height == 0)
- {
- return;
- }
-
- syncStateForTexImage();
-
- Box area(xoffset, yoffset, zoffset, width, height, depth);
- Texture *texture = getTargetTexture(target);
- handleError(texture->setCompressedSubImage(this, mGLState.getUnpackState(), target, level, area,
- format, imageSize,
- reinterpret_cast<const uint8_t *>(data)));
-}
-
-void Context::generateMipmap(GLenum target)
-{
- Texture *texture = getTargetTexture(target);
- handleError(texture->generateMipmap(this));
-}
-
-void Context::copyTextureCHROMIUM(GLuint sourceId,
- GLint sourceLevel,
- GLenum destTarget,
- GLuint destId,
- GLint destLevel,
- GLint internalFormat,
- GLenum destType,
- GLboolean unpackFlipY,
- GLboolean unpackPremultiplyAlpha,
- GLboolean unpackUnmultiplyAlpha)
-{
- syncStateForTexImage();
-
- gl::Texture *sourceTexture = getTexture(sourceId);
- gl::Texture *destTexture = getTexture(destId);
- handleError(destTexture->copyTexture(this, destTarget, destLevel, internalFormat, destType,
- sourceLevel, ConvertToBool(unpackFlipY),
- ConvertToBool(unpackPremultiplyAlpha),
- ConvertToBool(unpackUnmultiplyAlpha), sourceTexture));
-}
-
-void Context::copySubTextureCHROMIUM(GLuint sourceId,
- GLint sourceLevel,
- GLenum destTarget,
- GLuint destId,
- GLint destLevel,
- GLint xoffset,
- GLint yoffset,
- GLint x,
- GLint y,
- GLsizei width,
- GLsizei height,
- GLboolean unpackFlipY,
- GLboolean unpackPremultiplyAlpha,
- GLboolean unpackUnmultiplyAlpha)
-{
- // Zero sized copies are valid but no-ops
- if (width == 0 || height == 0)
- {
- return;
- }
-
- syncStateForTexImage();
-
- gl::Texture *sourceTexture = getTexture(sourceId);
- gl::Texture *destTexture = getTexture(destId);
- Offset offset(xoffset, yoffset, 0);
- Rectangle area(x, y, width, height);
- handleError(destTexture->copySubTexture(this, destTarget, destLevel, offset, sourceLevel, area,
- ConvertToBool(unpackFlipY),
- ConvertToBool(unpackPremultiplyAlpha),
- ConvertToBool(unpackUnmultiplyAlpha), sourceTexture));
-}
-
-void Context::compressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
-{
- syncStateForTexImage();
-
- gl::Texture *sourceTexture = getTexture(sourceId);
- gl::Texture *destTexture = getTexture(destId);
- handleError(destTexture->copyCompressedTexture(this, sourceTexture));
-}
-
-void Context::getBufferPointerv(BufferBinding target, GLenum pname, void **params)
-{
- Buffer *buffer = mGLState.getTargetBuffer(target);
- ASSERT(buffer);
-
- QueryBufferPointerv(buffer, pname, params);
-}
-
-void *Context::mapBuffer(BufferBinding target, GLenum access)
-{
- Buffer *buffer = mGLState.getTargetBuffer(target);
- ASSERT(buffer);
-
- Error error = buffer->map(this, access);
- if (error.isError())
- {
- handleError(error);
- return nullptr;
- }
-
- return buffer->getMapPointer();
-}
-
-GLboolean Context::unmapBuffer(BufferBinding target)
-{
- Buffer *buffer = mGLState.getTargetBuffer(target);
- ASSERT(buffer);
-
- GLboolean result;
- Error error = buffer->unmap(this, &result);
- if (error.isError())
- {
- handleError(error);
- return GL_FALSE;
- }
-
- return result;
-}
-
-void *Context::mapBufferRange(BufferBinding target,
- GLintptr offset,
- GLsizeiptr length,
- GLbitfield access)
-{
- Buffer *buffer = mGLState.getTargetBuffer(target);
- ASSERT(buffer);
-
- Error error = buffer->mapRange(this, offset, length, access);
- if (error.isError())
- {
- handleError(error);
- return nullptr;
- }
-
- return buffer->getMapPointer();
-}
-
-void Context::flushMappedBufferRange(BufferBinding /*target*/,
- GLintptr /*offset*/,
- GLsizeiptr /*length*/)
-{
- // We do not currently support a non-trivial implementation of FlushMappedBufferRange
-}
-
-void Context::syncStateForReadPixels()
-{
- syncRendererState(mReadPixelsDirtyBits, mReadPixelsDirtyObjects);
-}
-
-void Context::syncStateForTexImage()
-{
- syncRendererState(mTexImageDirtyBits, mTexImageDirtyObjects);
-}
-
-void Context::syncStateForClear()
-{
- syncRendererState(mClearDirtyBits, mClearDirtyObjects);
-}
-
-void Context::syncStateForBlit()
-{
- syncRendererState(mBlitDirtyBits, mBlitDirtyObjects);
-}
-
-void Context::activeShaderProgram(GLuint pipeline, GLuint program)
-{
- UNIMPLEMENTED();
-}
-
-void Context::activeTexture(GLenum texture)
-{
- mGLState.setActiveSampler(texture - GL_TEXTURE0);
-}
-
-void Context::blendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
- mGLState.setBlendColor(clamp01(red), clamp01(green), clamp01(blue), clamp01(alpha));
-}
-
-void Context::blendEquation(GLenum mode)
-{
- mGLState.setBlendEquation(mode, mode);
-}
-
-void Context::blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
- mGLState.setBlendEquation(modeRGB, modeAlpha);
-}
-
-void Context::blendFunc(GLenum sfactor, GLenum dfactor)
-{
- mGLState.setBlendFactors(sfactor, dfactor, sfactor, dfactor);
-}
-
-void Context::blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
- mGLState.setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-void Context::clearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
- mGLState.setColorClearValue(red, green, blue, alpha);
-}
-
-void Context::clearDepthf(GLfloat depth)
-{
- mGLState.setDepthClearValue(depth);
-}
-
-void Context::clearStencil(GLint s)
-{
- mGLState.setStencilClearValue(s);
-}
-
-void Context::colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
- mGLState.setColorMask(ConvertToBool(red), ConvertToBool(green), ConvertToBool(blue),
- ConvertToBool(alpha));
-}
-
-void Context::cullFace(CullFaceMode mode)
-{
- mGLState.setCullMode(mode);
-}
-
-void Context::depthFunc(GLenum func)
-{
- mGLState.setDepthFunc(func);
-}
-
-void Context::depthMask(GLboolean flag)
-{
- mGLState.setDepthMask(ConvertToBool(flag));
-}
-
-void Context::depthRangef(GLfloat zNear, GLfloat zFar)
-{
- mGLState.setDepthRange(zNear, zFar);
-}
-
-void Context::disable(GLenum cap)
-{
- mGLState.setEnableFeature(cap, false);
-}
-
-void Context::disableVertexAttribArray(GLuint index)
-{
- mGLState.setEnableVertexAttribArray(index, false);
-}
-
-void Context::enable(GLenum cap)
-{
- mGLState.setEnableFeature(cap, true);
-}
-
-void Context::enableVertexAttribArray(GLuint index)
-{
- mGLState.setEnableVertexAttribArray(index, true);
-}
-
-void Context::frontFace(GLenum mode)
-{
- mGLState.setFrontFace(mode);
-}
-
-void Context::hint(GLenum target, GLenum mode)
-{
- switch (target)
- {
- case GL_GENERATE_MIPMAP_HINT:
- mGLState.setGenerateMipmapHint(mode);
- break;
-
- case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
- mGLState.setFragmentShaderDerivativeHint(mode);
- break;
-
- default:
- UNREACHABLE();
- return;
- }
-}
-
-void Context::lineWidth(GLfloat width)
-{
- mGLState.setLineWidth(width);
-}
-
-void Context::pixelStorei(GLenum pname, GLint param)
-{
- switch (pname)
- {
- case GL_UNPACK_ALIGNMENT:
- mGLState.setUnpackAlignment(param);
- break;
-
- case GL_PACK_ALIGNMENT:
- mGLState.setPackAlignment(param);
- break;
-
- case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
- mGLState.setPackReverseRowOrder(param != 0);
- break;
-
- case GL_UNPACK_ROW_LENGTH:
- ASSERT((getClientMajorVersion() >= 3) || getExtensions().unpackSubimage);
- mGLState.setUnpackRowLength(param);
- break;
-
- case GL_UNPACK_IMAGE_HEIGHT:
- ASSERT(getClientMajorVersion() >= 3);
- mGLState.setUnpackImageHeight(param);
- break;
-
- case GL_UNPACK_SKIP_IMAGES:
- ASSERT(getClientMajorVersion() >= 3);
- mGLState.setUnpackSkipImages(param);
- break;
-
- case GL_UNPACK_SKIP_ROWS:
- ASSERT((getClientMajorVersion() >= 3) || getExtensions().unpackSubimage);
- mGLState.setUnpackSkipRows(param);
- break;
-
- case GL_UNPACK_SKIP_PIXELS:
- ASSERT((getClientMajorVersion() >= 3) || getExtensions().unpackSubimage);
- mGLState.setUnpackSkipPixels(param);
- break;
-
- case GL_PACK_ROW_LENGTH:
- ASSERT((getClientMajorVersion() >= 3) || getExtensions().packSubimage);
- mGLState.setPackRowLength(param);
- break;
-
- case GL_PACK_SKIP_ROWS:
- ASSERT((getClientMajorVersion() >= 3) || getExtensions().packSubimage);
- mGLState.setPackSkipRows(param);
- break;
-
- case GL_PACK_SKIP_PIXELS:
- ASSERT((getClientMajorVersion() >= 3) || getExtensions().packSubimage);
- mGLState.setPackSkipPixels(param);
- break;
-
- default:
- UNREACHABLE();
- return;
- }
-}
-
-void Context::polygonOffset(GLfloat factor, GLfloat units)
-{
- mGLState.setPolygonOffsetParams(factor, units);
-}
-
-void Context::sampleCoverage(GLfloat value, GLboolean invert)
-{
- mGLState.setSampleCoverageParams(clamp01(value), ConvertToBool(invert));
-}
-
-void Context::sampleMaski(GLuint maskNumber, GLbitfield mask)
-{
- mGLState.setSampleMaskParams(maskNumber, mask);
-}
-
-void Context::scissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
- mGLState.setScissorParams(x, y, width, height);
-}
-
-void Context::stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
- if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
- {
- mGLState.setStencilParams(func, ref, mask);
- }
-
- if (face == GL_BACK || face == GL_FRONT_AND_BACK)
- {
- mGLState.setStencilBackParams(func, ref, mask);
- }
-}
-
-void Context::stencilMaskSeparate(GLenum face, GLuint mask)
-{
- if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
- {
- mGLState.setStencilWritemask(mask);
- }
-
- if (face == GL_BACK || face == GL_FRONT_AND_BACK)
- {
- mGLState.setStencilBackWritemask(mask);
- }
-}
-
-void Context::stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
-{
- if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
- {
- mGLState.setStencilOperations(fail, zfail, zpass);
- }
-
- if (face == GL_BACK || face == GL_FRONT_AND_BACK)
- {
- mGLState.setStencilBackOperations(fail, zfail, zpass);
- }
-}
-
-void Context::vertexAttrib1f(GLuint index, GLfloat x)
-{
- GLfloat vals[4] = {x, 0, 0, 1};
- mGLState.setVertexAttribf(index, vals);
-}
-
-void Context::vertexAttrib1fv(GLuint index, const GLfloat *values)
-{
- GLfloat vals[4] = {values[0], 0, 0, 1};
- mGLState.setVertexAttribf(index, vals);
-}
-
-void Context::vertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
-{
- GLfloat vals[4] = {x, y, 0, 1};
- mGLState.setVertexAttribf(index, vals);
-}
-
-void Context::vertexAttrib2fv(GLuint index, const GLfloat *values)
-{
- GLfloat vals[4] = {values[0], values[1], 0, 1};
- mGLState.setVertexAttribf(index, vals);
-}
-
-void Context::vertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
- GLfloat vals[4] = {x, y, z, 1};
- mGLState.setVertexAttribf(index, vals);
-}
-
-void Context::vertexAttrib3fv(GLuint index, const GLfloat *values)
-{
- GLfloat vals[4] = {values[0], values[1], values[2], 1};
- mGLState.setVertexAttribf(index, vals);
-}
-
-void Context::vertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- GLfloat vals[4] = {x, y, z, w};
- mGLState.setVertexAttribf(index, vals);
-}
-
-void Context::vertexAttrib4fv(GLuint index, const GLfloat *values)
-{
- mGLState.setVertexAttribf(index, values);
-}
-
-void Context::vertexAttribPointer(GLuint index,
- GLint size,
- GLenum type,
- GLboolean normalized,
- GLsizei stride,
- const void *ptr)
-{
- mGLState.setVertexAttribPointer(this, index, mGLState.getTargetBuffer(BufferBinding::Array),
- size, type, ConvertToBool(normalized), false, stride, ptr);
-}
-
-void Context::vertexAttribFormat(GLuint attribIndex,
- GLint size,
- GLenum type,
- GLboolean normalized,
- GLuint relativeOffset)
-{
- mGLState.setVertexAttribFormat(attribIndex, size, type, ConvertToBool(normalized), false,
- relativeOffset);
-}
-
-void Context::vertexAttribIFormat(GLuint attribIndex,
- GLint size,
- GLenum type,
- GLuint relativeOffset)
-{
- mGLState.setVertexAttribFormat(attribIndex, size, type, false, true, relativeOffset);
-}
-
-void Context::vertexAttribBinding(GLuint attribIndex, GLuint bindingIndex)
-{
- mGLState.setVertexAttribBinding(this, attribIndex, bindingIndex);
-}
-
-void Context::vertexBindingDivisor(GLuint bindingIndex, GLuint divisor)
-{
- mGLState.setVertexBindingDivisor(bindingIndex, divisor);
-}
-
-void Context::viewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
- mGLState.setViewportParams(x, y, width, height);
-}
-
-void Context::vertexAttribIPointer(GLuint index,
- GLint size,
- GLenum type,
- GLsizei stride,
- const void *pointer)
-{
- mGLState.setVertexAttribPointer(this, index, mGLState.getTargetBuffer(BufferBinding::Array),
- size, type, false, true, stride, pointer);
-}
-
-void Context::vertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
- GLint vals[4] = {x, y, z, w};
- mGLState.setVertexAttribi(index, vals);
-}
-
-void Context::vertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
- GLuint vals[4] = {x, y, z, w};
- mGLState.setVertexAttribu(index, vals);
-}
-
-void Context::vertexAttribI4iv(GLuint index, const GLint *v)
-{
- mGLState.setVertexAttribi(index, v);
-}
-
-void Context::vertexAttribI4uiv(GLuint index, const GLuint *v)
-{
- mGLState.setVertexAttribu(index, v);
-}
-
-void Context::getVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-{
- const VertexAttribCurrentValueData &currentValues =
- getGLState().getVertexAttribCurrentValue(index);
- const VertexArray *vao = getGLState().getVertexArray();
- QueryVertexAttribiv(vao->getVertexAttribute(index), vao->getBindingFromAttribIndex(index),
- currentValues, pname, params);
-}
-
-void Context::getVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-{
- const VertexAttribCurrentValueData &currentValues =
- getGLState().getVertexAttribCurrentValue(index);
- const VertexArray *vao = getGLState().getVertexArray();
- QueryVertexAttribfv(vao->getVertexAttribute(index), vao->getBindingFromAttribIndex(index),
- currentValues, pname, params);
-}
-
-void Context::getVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-{
- const VertexAttribCurrentValueData &currentValues =
- getGLState().getVertexAttribCurrentValue(index);
- const VertexArray *vao = getGLState().getVertexArray();
- QueryVertexAttribIiv(vao->getVertexAttribute(index), vao->getBindingFromAttribIndex(index),
- currentValues, pname, params);
-}
-
-void Context::getVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-{
- const VertexAttribCurrentValueData &currentValues =
- getGLState().getVertexAttribCurrentValue(index);
- const VertexArray *vao = getGLState().getVertexArray();
- QueryVertexAttribIuiv(vao->getVertexAttribute(index), vao->getBindingFromAttribIndex(index),
- currentValues, pname, params);
-}
-
-void Context::getVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
-{
- const VertexAttribute &attrib = getGLState().getVertexArray()->getVertexAttribute(index);
- QueryVertexAttribPointerv(attrib, pname, pointer);
-}
-
-void Context::debugMessageControl(GLenum source,
- GLenum type,
- GLenum severity,
- GLsizei count,
- const GLuint *ids,
- GLboolean enabled)
-{
- std::vector<GLuint> idVector(ids, ids + count);
- mGLState.getDebug().setMessageControl(source, type, severity, std::move(idVector),
- ConvertToBool(enabled));
-}
-
-void Context::debugMessageInsert(GLenum source,
- GLenum type,
- GLuint id,
- GLenum severity,
- GLsizei length,
- const GLchar *buf)
-{
- std::string msg(buf, (length > 0) ? static_cast<size_t>(length) : strlen(buf));
- mGLState.getDebug().insertMessage(source, type, id, severity, std::move(msg));
-}
-
-void Context::debugMessageCallback(GLDEBUGPROCKHR callback, const void *userParam)
-{
- mGLState.getDebug().setCallback(callback, userParam);
-}
-
-GLuint Context::getDebugMessageLog(GLuint count,
- GLsizei bufSize,
- GLenum *sources,
- GLenum *types,
- GLuint *ids,
- GLenum *severities,
- GLsizei *lengths,
- GLchar *messageLog)
-{
- return static_cast<GLuint>(mGLState.getDebug().getMessages(count, bufSize, sources, types, ids,
- severities, lengths, messageLog));
-}
-
-void Context::pushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
-{
- std::string msg(message, (length > 0) ? static_cast<size_t>(length) : strlen(message));
- mGLState.getDebug().pushGroup(source, id, std::move(msg));
- mImplementation->pushDebugGroup(source, id, length, message);
-}
-
-void Context::popDebugGroup()
-{
- mGLState.getDebug().popGroup();
- mImplementation->popDebugGroup();
-}
-
-void Context::bufferData(BufferBinding target, GLsizeiptr size, const void *data, BufferUsage usage)
-{
- Buffer *buffer = mGLState.getTargetBuffer(target);
- ASSERT(buffer);
- handleError(buffer->bufferData(this, target, data, size, usage));
-}
-
-void Context::bufferSubData(BufferBinding target,
- GLintptr offset,
- GLsizeiptr size,
- const void *data)
-{
- if (data == nullptr)
- {
- return;
- }
-
- Buffer *buffer = mGLState.getTargetBuffer(target);
- ASSERT(buffer);
- handleError(buffer->bufferSubData(this, target, data, size, offset));
-}
-
-void Context::attachShader(GLuint program, GLuint shader)
-{
- Program *programObject = mState.mShaderPrograms->getProgram(program);
- Shader *shaderObject = mState.mShaderPrograms->getShader(shader);
- ASSERT(programObject && shaderObject);
- programObject->attachShader(shaderObject);
-}
-
-const Workarounds &Context::getWorkarounds() const
-{
- return mWorkarounds;
-}
-
-void Context::copyBufferSubData(BufferBinding readTarget,
- BufferBinding writeTarget,
- GLintptr readOffset,
- GLintptr writeOffset,
- GLsizeiptr size)
-{
- // if size is zero, the copy is a successful no-op
- if (size == 0)
- {
- return;
- }
-
- // TODO(jmadill): cache these.
- Buffer *readBuffer = mGLState.getTargetBuffer(readTarget);
- Buffer *writeBuffer = mGLState.getTargetBuffer(writeTarget);
-
- handleError(writeBuffer->copyBufferSubData(this, readBuffer, readOffset, writeOffset, size));
-}
-
-void Context::bindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-{
- Program *programObject = getProgram(program);
- // TODO(jmadill): Re-use this from the validation if possible.
- ASSERT(programObject);
- programObject->bindAttributeLocation(index, name);
-}
-
-void Context::bindBuffer(BufferBinding target, GLuint buffer)
-{
- Buffer *bufferObject = mState.mBuffers->checkBufferAllocation(mImplementation.get(), buffer);
- mGLState.setBufferBinding(this, target, bufferObject);
-}
-
-void Context::bindBufferBase(BufferBinding target, GLuint index, GLuint buffer)
-{
- bindBufferRange(target, index, buffer, 0, 0);
-}
-
-void Context::bindBufferRange(BufferBinding target,
- GLuint index,
- GLuint buffer,
- GLintptr offset,
- GLsizeiptr size)
-{
- Buffer *bufferObject = mState.mBuffers->checkBufferAllocation(mImplementation.get(), buffer);
- mGLState.setIndexedBufferBinding(this, target, index, bufferObject, offset, size);
-}
-
-void Context::bindFramebuffer(GLenum target, GLuint framebuffer)
-{
- if (target == GL_READ_FRAMEBUFFER || target == GL_FRAMEBUFFER)
- {
- bindReadFramebuffer(framebuffer);
- }
-
- if (target == GL_DRAW_FRAMEBUFFER || target == GL_FRAMEBUFFER)
- {
- bindDrawFramebuffer(framebuffer);
- }
-}
-
-void Context::bindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
- ASSERT(target == GL_RENDERBUFFER);
- Renderbuffer *object =
- mState.mRenderbuffers->checkRenderbufferAllocation(mImplementation.get(), renderbuffer);
- mGLState.setRenderbufferBinding(this, object);
-}
-
-void Context::texStorage2DMultisample(GLenum target,
- GLsizei samples,
- GLenum internalformat,
- GLsizei width,
- GLsizei height,
- GLboolean fixedsamplelocations)
-{
- Extents size(width, height, 1);
- Texture *texture = getTargetTexture(target);
- handleError(texture->setStorageMultisample(this, target, samples, internalformat, size,
- ConvertToBool(fixedsamplelocations)));
-}
-
-void Context::getMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
- // According to spec 3.1 Table 20.49: Framebuffer Dependent Values,
- // the sample position should be queried by DRAW_FRAMEBUFFER.
- mGLState.syncDirtyObject(this, GL_DRAW_FRAMEBUFFER);
- const Framebuffer *framebuffer = mGLState.getDrawFramebuffer();
-
- switch (pname)
- {
- case GL_SAMPLE_POSITION:
- handleError(framebuffer->getSamplePosition(index, val));
- break;
- default:
- UNREACHABLE();
- }
-}
-
-void Context::renderbufferStorage(GLenum target,
- GLenum internalformat,
- GLsizei width,
- GLsizei height)
-{
- // Hack for the special WebGL 1 "DEPTH_STENCIL" internal format.
- GLenum convertedInternalFormat = getConvertedRenderbufferFormat(internalformat);
-
- Renderbuffer *renderbuffer = mGLState.getCurrentRenderbuffer();
- handleError(renderbuffer->setStorage(this, convertedInternalFormat, width, height));
-}
-
-void Context::renderbufferStorageMultisample(GLenum target,
- GLsizei samples,
- GLenum internalformat,
- GLsizei width,
- GLsizei height)
-{
- // Hack for the special WebGL 1 "DEPTH_STENCIL" internal format.
- GLenum convertedInternalFormat = getConvertedRenderbufferFormat(internalformat);
-
- Renderbuffer *renderbuffer = mGLState.getCurrentRenderbuffer();
- handleError(
- renderbuffer->setStorageMultisample(this, samples, convertedInternalFormat, width, height));
-}
-
-void Context::getSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-{
- const Sync *syncObject = getSync(sync);
- handleError(QuerySynciv(syncObject, pname, bufSize, length, values));
-}
-
-void Context::getFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- QueryFramebufferParameteriv(framebuffer, pname, params);
-}
-
-void Context::framebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- SetFramebufferParameteri(framebuffer, pname, param);
-}
-
-Error Context::getScratchBuffer(size_t requstedSizeBytes,
- angle::MemoryBuffer **scratchBufferOut) const
-{
- if (!mScratchBuffer.get(requstedSizeBytes, scratchBufferOut))
- {
- return OutOfMemory() << "Failed to allocate internal buffer.";
- }
- return NoError();
-}
-
-Error Context::getZeroFilledBuffer(size_t requstedSizeBytes,
- angle::MemoryBuffer **zeroBufferOut) const
-{
- if (!mZeroFilledBuffer.getInitialized(requstedSizeBytes, zeroBufferOut, 0))
- {
- return OutOfMemory() << "Failed to allocate internal buffer.";
- }
- return NoError();
-}
-
-void Context::dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ)
-{
- if (numGroupsX == 0u || numGroupsY == 0u || numGroupsZ == 0u)
- {
- return;
- }
-
- // TODO(jmadill): Dirty bits for compute.
- if (isRobustResourceInitEnabled())
- {
- ANGLE_CONTEXT_TRY(mGLState.clearUnclearedActiveTextures(this));
- }
-
- handleError(mImplementation->dispatchCompute(this, numGroupsX, numGroupsY, numGroupsZ));
-}
-
-void Context::dispatchComputeIndirect(GLintptr indirect)
-{
- UNIMPLEMENTED();
-}
-
-void Context::texStorage2D(GLenum target,
- GLsizei levels,
- GLenum internalFormat,
- GLsizei width,
- GLsizei height)
-{
- Extents size(width, height, 1);
- Texture *texture = getTargetTexture(target);
- handleError(texture->setStorage(this, target, levels, internalFormat, size));
-}
-
-void Context::texStorage3D(GLenum target,
- GLsizei levels,
- GLenum internalFormat,
- GLsizei width,
- GLsizei height,
- GLsizei depth)
-{
- Extents size(width, height, depth);
- Texture *texture = getTargetTexture(target);
- handleError(texture->setStorage(this, target, levels, internalFormat, size));
-}
-
-void Context::memoryBarrier(GLbitfield barriers)
-{
- UNIMPLEMENTED();
-}
-
-void Context::memoryBarrierByRegion(GLbitfield barriers)
-{
- UNIMPLEMENTED();
-}
-
-GLenum Context::checkFramebufferStatus(GLenum target)
-{
- Framebuffer *framebuffer = mGLState.getTargetFramebuffer(target);
- ASSERT(framebuffer);
-
- return framebuffer->checkStatus(this);
-}
-
-void Context::compileShader(GLuint shader)
-{
- Shader *shaderObject = GetValidShader(this, shader);
- if (!shaderObject)
- {
- return;
- }
- shaderObject->compile(this);
-}
-
-void Context::deleteBuffers(GLsizei n, const GLuint *buffers)
-{
- for (int i = 0; i < n; i++)
- {
- deleteBuffer(buffers[i]);
- }
-}
-
-void Context::deleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-{
- for (int i = 0; i < n; i++)
- {
- if (framebuffers[i] != 0)
- {
- deleteFramebuffer(framebuffers[i]);
- }
- }
-}
-
-void Context::deleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-{
- for (int i = 0; i < n; i++)
- {
- deleteRenderbuffer(renderbuffers[i]);
- }
-}
-
-void Context::deleteTextures(GLsizei n, const GLuint *textures)
-{
- for (int i = 0; i < n; i++)
- {
- if (textures[i] != 0)
- {
- deleteTexture(textures[i]);
- }
- }
-}
-
-void Context::detachShader(GLuint program, GLuint shader)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
-
- Shader *shaderObject = getShader(shader);
- ASSERT(shaderObject);
-
- programObject->detachShader(this, shaderObject);
-}
-
-void Context::genBuffers(GLsizei n, GLuint *buffers)
-{
- for (int i = 0; i < n; i++)
- {
- buffers[i] = createBuffer();
- }
-}
-
-void Context::genFramebuffers(GLsizei n, GLuint *framebuffers)
-{
- for (int i = 0; i < n; i++)
- {
- framebuffers[i] = createFramebuffer();
- }
-}
-
-void Context::genRenderbuffers(GLsizei n, GLuint *renderbuffers)
-{
- for (int i = 0; i < n; i++)
- {
- renderbuffers[i] = createRenderbuffer();
- }
-}
-
-void Context::genTextures(GLsizei n, GLuint *textures)
-{
- for (int i = 0; i < n; i++)
- {
- textures[i] = createTexture();
- }
-}
-
-void Context::getActiveAttrib(GLuint program,
- GLuint index,
- GLsizei bufsize,
- GLsizei *length,
- GLint *size,
- GLenum *type,
- GLchar *name)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->getActiveAttribute(index, bufsize, length, size, type, name);
-}
-
-void Context::getActiveUniform(GLuint program,
- GLuint index,
- GLsizei bufsize,
- GLsizei *length,
- GLint *size,
- GLenum *type,
- GLchar *name)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->getActiveUniform(index, bufsize, length, size, type, name);
-}
-
-void Context::getAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->getAttachedShaders(maxcount, count, shaders);
-}
-
-GLint Context::getAttribLocation(GLuint program, const GLchar *name)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- return programObject->getAttributeLocation(name);
-}
-
-void Context::getBooleanv(GLenum pname, GLboolean *params)
-{
- GLenum nativeType;
- unsigned int numParams = 0;
- getQueryParameterInfo(pname, &nativeType, &numParams);
-
- if (nativeType == GL_BOOL)
- {
- getBooleanvImpl(pname, params);
- }
- else
- {
- CastStateValues(this, nativeType, pname, numParams, params);
- }
-}
-
-void Context::getFloatv(GLenum pname, GLfloat *params)
-{
- GLenum nativeType;
- unsigned int numParams = 0;
- getQueryParameterInfo(pname, &nativeType, &numParams);
-
- if (nativeType == GL_FLOAT)
- {
- getFloatvImpl(pname, params);
- }
- else
- {
- CastStateValues(this, nativeType, pname, numParams, params);
- }
-}
-
-void Context::getIntegerv(GLenum pname, GLint *params)
-{
- GLenum nativeType;
- unsigned int numParams = 0;
- getQueryParameterInfo(pname, &nativeType, &numParams);
-
- if (nativeType == GL_INT)
- {
- getIntegervImpl(pname, params);
- }
- else
- {
- CastStateValues(this, nativeType, pname, numParams, params);
- }
-}
-
-void Context::getProgramiv(GLuint program, GLenum pname, GLint *params)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- QueryProgramiv(this, programObject, pname, params);
-}
-
-void Context::getProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
-{
- UNIMPLEMENTED();
-}
-
-void Context::getProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length, GLchar *infolog)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->getInfoLog(bufsize, length, infolog);
-}
-
-void Context::getProgramPipelineInfoLog(GLuint pipeline,
- GLsizei bufSize,
- GLsizei *length,
- GLchar *infoLog)
-{
- UNIMPLEMENTED();
-}
-
-void Context::getShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
- Shader *shaderObject = getShader(shader);
- ASSERT(shaderObject);
- QueryShaderiv(this, shaderObject, pname, params);
-}
-
-void Context::getShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *infolog)
-{
- Shader *shaderObject = getShader(shader);
- ASSERT(shaderObject);
- shaderObject->getInfoLog(this, bufsize, length, infolog);
-}
-
-void Context::getShaderPrecisionFormat(GLenum shadertype,
- GLenum precisiontype,
- GLint *range,
- GLint *precision)
-{
- // TODO(jmadill): Compute shaders.
-
- switch (shadertype)
- {
- case GL_VERTEX_SHADER:
- switch (precisiontype)
- {
- case GL_LOW_FLOAT:
- mCaps.vertexLowpFloat.get(range, precision);
- break;
- case GL_MEDIUM_FLOAT:
- mCaps.vertexMediumpFloat.get(range, precision);
- break;
- case GL_HIGH_FLOAT:
- mCaps.vertexHighpFloat.get(range, precision);
- break;
-
- case GL_LOW_INT:
- mCaps.vertexLowpInt.get(range, precision);
- break;
- case GL_MEDIUM_INT:
- mCaps.vertexMediumpInt.get(range, precision);
- break;
- case GL_HIGH_INT:
- mCaps.vertexHighpInt.get(range, precision);
- break;
-
- default:
- UNREACHABLE();
- return;
- }
- break;
-
- case GL_FRAGMENT_SHADER:
- switch (precisiontype)
- {
- case GL_LOW_FLOAT:
- mCaps.fragmentLowpFloat.get(range, precision);
- break;
- case GL_MEDIUM_FLOAT:
- mCaps.fragmentMediumpFloat.get(range, precision);
- break;
- case GL_HIGH_FLOAT:
- mCaps.fragmentHighpFloat.get(range, precision);
- break;
-
- case GL_LOW_INT:
- mCaps.fragmentLowpInt.get(range, precision);
- break;
- case GL_MEDIUM_INT:
- mCaps.fragmentMediumpInt.get(range, precision);
- break;
- case GL_HIGH_INT:
- mCaps.fragmentHighpInt.get(range, precision);
- break;
-
- default:
- UNREACHABLE();
- return;
- }
- break;
-
- default:
- UNREACHABLE();
- return;
- }
-}
-
-void Context::getShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *source)
-{
- Shader *shaderObject = getShader(shader);
- ASSERT(shaderObject);
- shaderObject->getSource(bufsize, length, source);
-}
-
-void Context::getUniformfv(GLuint program, GLint location, GLfloat *params)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->getUniformfv(this, location, params);
-}
-
-void Context::getUniformiv(GLuint program, GLint location, GLint *params)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->getUniformiv(this, location, params);
-}
-
-GLint Context::getUniformLocation(GLuint program, const GLchar *name)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- return programObject->getUniformLocation(name);
-}
-
-GLboolean Context::isBuffer(GLuint buffer)
-{
- if (buffer == 0)
- {
- return GL_FALSE;
- }
-
- return (getBuffer(buffer) ? GL_TRUE : GL_FALSE);
-}
-
-GLboolean Context::isEnabled(GLenum cap)
-{
- return mGLState.getEnableFeature(cap);
-}
-
-GLboolean Context::isFramebuffer(GLuint framebuffer)
-{
- if (framebuffer == 0)
- {
- return GL_FALSE;
- }
-
- return (getFramebuffer(framebuffer) ? GL_TRUE : GL_FALSE);
-}
-
-GLboolean Context::isProgram(GLuint program)
-{
- if (program == 0)
- {
- return GL_FALSE;
- }
-
- return (getProgram(program) ? GL_TRUE : GL_FALSE);
-}
-
-GLboolean Context::isRenderbuffer(GLuint renderbuffer)
-{
- if (renderbuffer == 0)
- {
- return GL_FALSE;
- }
-
- return (getRenderbuffer(renderbuffer) ? GL_TRUE : GL_FALSE);
-}
-
-GLboolean Context::isShader(GLuint shader)
-{
- if (shader == 0)
- {
- return GL_FALSE;
- }
-
- return (getShader(shader) ? GL_TRUE : GL_FALSE);
-}
-
-GLboolean Context::isTexture(GLuint texture)
-{
- if (texture == 0)
- {
- return GL_FALSE;
- }
-
- return (getTexture(texture) ? GL_TRUE : GL_FALSE);
-}
-
-void Context::linkProgram(GLuint program)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- handleError(programObject->link(this));
- mGLState.onProgramExecutableChange(programObject);
-}
-
-void Context::releaseShaderCompiler()
-{
- mCompiler.set(this, nullptr);
-}
-
-void Context::shaderBinary(GLsizei n,
- const GLuint *shaders,
- GLenum binaryformat,
- const void *binary,
- GLsizei length)
-{
- // No binary shader formats are supported.
- UNIMPLEMENTED();
-}
-
-void Context::shaderSource(GLuint shader,
- GLsizei count,
- const GLchar *const *string,
- const GLint *length)
-{
- Shader *shaderObject = getShader(shader);
- ASSERT(shaderObject);
- shaderObject->setSource(count, string, length);
-}
-
-void Context::stencilFunc(GLenum func, GLint ref, GLuint mask)
-{
- stencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
-}
-
-void Context::stencilMask(GLuint mask)
-{
- stencilMaskSeparate(GL_FRONT_AND_BACK, mask);
-}
-
-void Context::stencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
- stencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
-}
-
-void Context::uniform1f(GLint location, GLfloat x)
-{
- Program *program = mGLState.getProgram();
- program->setUniform1fv(location, 1, &x);
-}
-
-void Context::uniform1fv(GLint location, GLsizei count, const GLfloat *v)
-{
- Program *program = mGLState.getProgram();
- program->setUniform1fv(location, count, v);
-}
-
-void Context::uniform1i(GLint location, GLint x)
-{
- Program *program = mGLState.getProgram();
- if (program->setUniform1iv(location, 1, &x) == Program::SetUniformResult::SamplerChanged)
- {
- mGLState.setObjectDirty(GL_PROGRAM);
- }
-}
-
-void Context::uniform1iv(GLint location, GLsizei count, const GLint *v)
-{
- Program *program = mGLState.getProgram();
- if (program->setUniform1iv(location, count, v) == Program::SetUniformResult::SamplerChanged)
- {
- mGLState.setObjectDirty(GL_PROGRAM);
- }
-}
-
-void Context::uniform2f(GLint location, GLfloat x, GLfloat y)
-{
- GLfloat xy[2] = {x, y};
- Program *program = mGLState.getProgram();
- program->setUniform2fv(location, 1, xy);
-}
-
-void Context::uniform2fv(GLint location, GLsizei count, const GLfloat *v)
-{
- Program *program = mGLState.getProgram();
- program->setUniform2fv(location, count, v);
-}
-
-void Context::uniform2i(GLint location, GLint x, GLint y)
-{
- GLint xy[2] = {x, y};
- Program *program = mGLState.getProgram();
- program->setUniform2iv(location, 1, xy);
-}
-
-void Context::uniform2iv(GLint location, GLsizei count, const GLint *v)
-{
- Program *program = mGLState.getProgram();
- program->setUniform2iv(location, count, v);
-}
-
-void Context::uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
-{
- GLfloat xyz[3] = {x, y, z};
- Program *program = mGLState.getProgram();
- program->setUniform3fv(location, 1, xyz);
-}
-
-void Context::uniform3fv(GLint location, GLsizei count, const GLfloat *v)
-{
- Program *program = mGLState.getProgram();
- program->setUniform3fv(location, count, v);
-}
-
-void Context::uniform3i(GLint location, GLint x, GLint y, GLint z)
-{
- GLint xyz[3] = {x, y, z};
- Program *program = mGLState.getProgram();
- program->setUniform3iv(location, 1, xyz);
-}
-
-void Context::uniform3iv(GLint location, GLsizei count, const GLint *v)
-{
- Program *program = mGLState.getProgram();
- program->setUniform3iv(location, count, v);
-}
-
-void Context::uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- GLfloat xyzw[4] = {x, y, z, w};
- Program *program = mGLState.getProgram();
- program->setUniform4fv(location, 1, xyzw);
-}
-
-void Context::uniform4fv(GLint location, GLsizei count, const GLfloat *v)
-{
- Program *program = mGLState.getProgram();
- program->setUniform4fv(location, count, v);
-}
-
-void Context::uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
-{
- GLint xyzw[4] = {x, y, z, w};
- Program *program = mGLState.getProgram();
- program->setUniform4iv(location, 1, xyzw);
-}
-
-void Context::uniform4iv(GLint location, GLsizei count, const GLint *v)
-{
- Program *program = mGLState.getProgram();
- program->setUniform4iv(location, count, v);
-}
-
-void Context::uniformMatrix2fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix2fv(location, count, transpose, value);
-}
-
-void Context::uniformMatrix3fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix3fv(location, count, transpose, value);
-}
-
-void Context::uniformMatrix4fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix4fv(location, count, transpose, value);
-}
-
-void Context::validateProgram(GLuint program)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->validate(mCaps);
-}
-
-void Context::validateProgramPipeline(GLuint pipeline)
-{
- UNIMPLEMENTED();
-}
-
-void Context::getProgramBinary(GLuint program,
- GLsizei bufSize,
- GLsizei *length,
- GLenum *binaryFormat,
- void *binary)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject != nullptr);
-
- handleError(programObject->saveBinary(this, binaryFormat, binary, bufSize, length));
-}
-
-void Context::programBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject != nullptr);
-
- handleError(programObject->loadBinary(this, binaryFormat, binary, length));
-}
-
-void Context::uniform1ui(GLint location, GLuint v0)
-{
- Program *program = mGLState.getProgram();
- program->setUniform1uiv(location, 1, &v0);
-}
-
-void Context::uniform2ui(GLint location, GLuint v0, GLuint v1)
-{
- Program *program = mGLState.getProgram();
- const GLuint xy[] = {v0, v1};
- program->setUniform2uiv(location, 1, xy);
-}
-
-void Context::uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
- Program *program = mGLState.getProgram();
- const GLuint xyz[] = {v0, v1, v2};
- program->setUniform3uiv(location, 1, xyz);
-}
-
-void Context::uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
- Program *program = mGLState.getProgram();
- const GLuint xyzw[] = {v0, v1, v2, v3};
- program->setUniform4uiv(location, 1, xyzw);
-}
-
-void Context::uniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniform1uiv(location, count, value);
-}
-void Context::uniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniform2uiv(location, count, value);
-}
-
-void Context::uniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniform3uiv(location, count, value);
-}
-
-void Context::uniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniform4uiv(location, count, value);
-}
-
-void Context::genQueries(GLsizei n, GLuint *ids)
-{
- for (GLsizei i = 0; i < n; i++)
- {
- GLuint handle = mQueryHandleAllocator.allocate();
- mQueryMap.assign(handle, nullptr);
- ids[i] = handle;
- }
-}
-
-void Context::deleteQueries(GLsizei n, const GLuint *ids)
-{
- for (int i = 0; i < n; i++)
- {
- GLuint query = ids[i];
-
- Query *queryObject = nullptr;
- if (mQueryMap.erase(query, &queryObject))
- {
- mQueryHandleAllocator.release(query);
- if (queryObject)
- {
- queryObject->release(this);
- }
- }
- }
-}
-
-GLboolean Context::isQuery(GLuint id)
-{
- return (getQuery(id, false, GL_NONE) != nullptr) ? GL_TRUE : GL_FALSE;
-}
-
-void Context::uniformMatrix2x3fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix2x3fv(location, count, transpose, value);
-}
-
-void Context::uniformMatrix3x2fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix3x2fv(location, count, transpose, value);
-}
-
-void Context::uniformMatrix2x4fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix2x4fv(location, count, transpose, value);
-}
-
-void Context::uniformMatrix4x2fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix4x2fv(location, count, transpose, value);
-}
-
-void Context::uniformMatrix3x4fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix3x4fv(location, count, transpose, value);
-}
-
-void Context::uniformMatrix4x3fv(GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *program = mGLState.getProgram();
- program->setUniformMatrix4x3fv(location, count, transpose, value);
-}
-
-void Context::deleteVertexArrays(GLsizei n, const GLuint *arrays)
-{
- for (int arrayIndex = 0; arrayIndex < n; arrayIndex++)
- {
- GLuint vertexArray = arrays[arrayIndex];
-
- if (arrays[arrayIndex] != 0)
- {
- VertexArray *vertexArrayObject = nullptr;
- if (mVertexArrayMap.erase(vertexArray, &vertexArrayObject))
- {
- if (vertexArrayObject != nullptr)
- {
- detachVertexArray(vertexArray);
- vertexArrayObject->onDestroy(this);
- }
-
- mVertexArrayHandleAllocator.release(vertexArray);
- }
- }
- }
-}
-
-void Context::genVertexArrays(GLsizei n, GLuint *arrays)
-{
- for (int arrayIndex = 0; arrayIndex < n; arrayIndex++)
- {
- GLuint vertexArray = mVertexArrayHandleAllocator.allocate();
- mVertexArrayMap.assign(vertexArray, nullptr);
- arrays[arrayIndex] = vertexArray;
- }
-}
-
-bool Context::isVertexArray(GLuint array)
-{
- if (array == 0)
- {
- return GL_FALSE;
- }
-
- VertexArray *vao = getVertexArray(array);
- return (vao != nullptr ? GL_TRUE : GL_FALSE);
-}
-
-void Context::endTransformFeedback()
-{
- TransformFeedback *transformFeedback = mGLState.getCurrentTransformFeedback();
- transformFeedback->end(this);
-}
-
-void Context::transformFeedbackVaryings(GLuint program,
- GLsizei count,
- const GLchar *const *varyings,
- GLenum bufferMode)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setTransformFeedbackVaryings(count, varyings, bufferMode);
-}
-
-void Context::getTransformFeedbackVarying(GLuint program,
- GLuint index,
- GLsizei bufSize,
- GLsizei *length,
- GLsizei *size,
- GLenum *type,
- GLchar *name)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->getTransformFeedbackVarying(index, bufSize, length, size, type, name);
-}
-
-void Context::deleteTransformFeedbacks(GLsizei n, const GLuint *ids)
-{
- for (int i = 0; i < n; i++)
- {
- GLuint transformFeedback = ids[i];
- if (transformFeedback == 0)
- {
- continue;
- }
-
- TransformFeedback *transformFeedbackObject = nullptr;
- if (mTransformFeedbackMap.erase(transformFeedback, &transformFeedbackObject))
- {
- if (transformFeedbackObject != nullptr)
- {
- detachTransformFeedback(transformFeedback);
- transformFeedbackObject->release(this);
- }
-
- mTransformFeedbackHandleAllocator.release(transformFeedback);
- }
- }
-}
-
-void Context::genTransformFeedbacks(GLsizei n, GLuint *ids)
-{
- for (int i = 0; i < n; i++)
- {
- GLuint transformFeedback = mTransformFeedbackHandleAllocator.allocate();
- mTransformFeedbackMap.assign(transformFeedback, nullptr);
- ids[i] = transformFeedback;
- }
-}
-
-bool Context::isTransformFeedback(GLuint id)
-{
- if (id == 0)
- {
- // The 3.0.4 spec [section 6.1.11] states that if ID is zero, IsTransformFeedback
- // returns FALSE
- return GL_FALSE;
- }
-
- const TransformFeedback *transformFeedback = getTransformFeedback(id);
- return ((transformFeedback != nullptr) ? GL_TRUE : GL_FALSE);
-}
-
-void Context::pauseTransformFeedback()
-{
- TransformFeedback *transformFeedback = mGLState.getCurrentTransformFeedback();
- transformFeedback->pause();
-}
-
-void Context::resumeTransformFeedback()
-{
- TransformFeedback *transformFeedback = mGLState.getCurrentTransformFeedback();
- transformFeedback->resume();
-}
-
-void Context::getUniformuiv(GLuint program, GLint location, GLuint *params)
-{
- const Program *programObject = getProgram(program);
- programObject->getUniformuiv(this, location, params);
-}
-
-GLint Context::getFragDataLocation(GLuint program, const GLchar *name)
-{
- const Program *programObject = getProgram(program);
- return programObject->getFragDataLocation(name);
-}
-
-void Context::getUniformIndices(GLuint program,
- GLsizei uniformCount,
- const GLchar *const *uniformNames,
- GLuint *uniformIndices)
-{
- const Program *programObject = getProgram(program);
- if (!programObject->isLinked())
- {
- for (int uniformId = 0; uniformId < uniformCount; uniformId++)
- {
- uniformIndices[uniformId] = GL_INVALID_INDEX;
- }
- }
- else
- {
- for (int uniformId = 0; uniformId < uniformCount; uniformId++)
- {
- uniformIndices[uniformId] = programObject->getUniformIndex(uniformNames[uniformId]);
- }
- }
-}
-
-void Context::getActiveUniformsiv(GLuint program,
- GLsizei uniformCount,
- const GLuint *uniformIndices,
- GLenum pname,
- GLint *params)
-{
- const Program *programObject = getProgram(program);
- for (int uniformId = 0; uniformId < uniformCount; uniformId++)
- {
- const GLuint index = uniformIndices[uniformId];
- params[uniformId] = GetUniformResourceProperty(programObject, index, pname);
- }
-}
-
-GLuint Context::getUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-{
- const Program *programObject = getProgram(program);
- return programObject->getUniformBlockIndex(uniformBlockName);
-}
-
-void Context::getActiveUniformBlockiv(GLuint program,
- GLuint uniformBlockIndex,
- GLenum pname,
- GLint *params)
-{
- const Program *programObject = getProgram(program);
- QueryActiveUniformBlockiv(programObject, uniformBlockIndex, pname, params);
-}
-
-void Context::getActiveUniformBlockName(GLuint program,
- GLuint uniformBlockIndex,
- GLsizei bufSize,
- GLsizei *length,
- GLchar *uniformBlockName)
-{
- const Program *programObject = getProgram(program);
- programObject->getActiveUniformBlockName(uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-void Context::uniformBlockBinding(GLuint program,
- GLuint uniformBlockIndex,
- GLuint uniformBlockBinding)
-{
- Program *programObject = getProgram(program);
- programObject->bindUniformBlock(uniformBlockIndex, uniformBlockBinding);
-}
-
-GLsync Context::fenceSync(GLenum condition, GLbitfield flags)
-{
- GLuint handle = mState.mSyncs->createSync(mImplementation.get());
- GLsync syncHandle = reinterpret_cast<GLsync>(static_cast<uintptr_t>(handle));
-
- Sync *syncObject = getSync(syncHandle);
- Error error = syncObject->set(condition, flags);
- if (error.isError())
- {
- deleteSync(syncHandle);
- handleError(error);
- return nullptr;
- }
-
- return syncHandle;
-}
-
-GLboolean Context::isSync(GLsync sync)
-{
- return (getSync(sync) != nullptr);
-}
-
-GLenum Context::clientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
- Sync *syncObject = getSync(sync);
-
- GLenum result = GL_WAIT_FAILED;
- handleError(syncObject->clientWait(flags, timeout, &result));
- return result;
-}
-
-void Context::waitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
- Sync *syncObject = getSync(sync);
- handleError(syncObject->serverWait(flags, timeout));
-}
-
-void Context::getInteger64v(GLenum pname, GLint64 *params)
-{
- GLenum nativeType = GL_NONE;
- unsigned int numParams = 0;
- getQueryParameterInfo(pname, &nativeType, &numParams);
-
- if (nativeType == GL_INT_64_ANGLEX)
- {
- getInteger64vImpl(pname, params);
- }
- else
- {
- CastStateValues(this, nativeType, pname, numParams, params);
- }
-}
-
-void Context::getBufferParameteri64v(BufferBinding target, GLenum pname, GLint64 *params)
-{
- Buffer *buffer = mGLState.getTargetBuffer(target);
- QueryBufferParameteri64v(buffer, pname, params);
-}
-
-void Context::genSamplers(GLsizei count, GLuint *samplers)
-{
- for (int i = 0; i < count; i++)
- {
- samplers[i] = mState.mSamplers->createSampler();
- }
-}
-
-void Context::deleteSamplers(GLsizei count, const GLuint *samplers)
-{
- for (int i = 0; i < count; i++)
- {
- GLuint sampler = samplers[i];
-
- if (mState.mSamplers->getSampler(sampler))
- {
- detachSampler(sampler);
- }
-
- mState.mSamplers->deleteObject(this, sampler);
- }
-}
-
-void Context::getInternalformativ(GLenum target,
- GLenum internalformat,
- GLenum pname,
- GLsizei bufSize,
- GLint *params)
-{
- const TextureCaps &formatCaps = mTextureCaps.get(internalformat);
- QueryInternalFormativ(formatCaps, pname, bufSize, params);
-}
-
-void Context::programUniform1i(GLuint program, GLint location, GLint v0)
-{
- programUniform1iv(program, location, 1, &v0);
-}
-
-void Context::programUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
- GLint xy[2] = {v0, v1};
- programUniform2iv(program, location, 1, xy);
-}
-
-void Context::programUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
- GLint xyz[3] = {v0, v1, v2};
- programUniform3iv(program, location, 1, xyz);
-}
-
-void Context::programUniform4i(GLuint program,
- GLint location,
- GLint v0,
- GLint v1,
- GLint v2,
- GLint v3)
-{
- GLint xyzw[4] = {v0, v1, v2, v3};
- programUniform4iv(program, location, 1, xyzw);
-}
-
-void Context::programUniform1ui(GLuint program, GLint location, GLuint v0)
-{
- programUniform1uiv(program, location, 1, &v0);
-}
-
-void Context::programUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
- GLuint xy[2] = {v0, v1};
- programUniform2uiv(program, location, 1, xy);
-}
-
-void Context::programUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
- GLuint xyz[3] = {v0, v1, v2};
- programUniform3uiv(program, location, 1, xyz);
-}
-
-void Context::programUniform4ui(GLuint program,
- GLint location,
- GLuint v0,
- GLuint v1,
- GLuint v2,
- GLuint v3)
-{
- GLuint xyzw[4] = {v0, v1, v2, v3};
- programUniform4uiv(program, location, 1, xyzw);
-}
-
-void Context::programUniform1f(GLuint program, GLint location, GLfloat v0)
-{
- programUniform1fv(program, location, 1, &v0);
-}
-
-void Context::programUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
- GLfloat xy[2] = {v0, v1};
- programUniform2fv(program, location, 1, xy);
-}
-
-void Context::programUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
- GLfloat xyz[3] = {v0, v1, v2};
- programUniform3fv(program, location, 1, xyz);
-}
-
-void Context::programUniform4f(GLuint program,
- GLint location,
- GLfloat v0,
- GLfloat v1,
- GLfloat v2,
- GLfloat v3)
-{
- GLfloat xyzw[4] = {v0, v1, v2, v3};
- programUniform4fv(program, location, 1, xyzw);
-}
-
-void Context::programUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- if (programObject->setUniform1iv(location, count, value) ==
- Program::SetUniformResult::SamplerChanged)
- {
- mGLState.setObjectDirty(GL_PROGRAM);
- }
-}
-
-void Context::programUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform2iv(location, count, value);
-}
-
-void Context::programUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform3iv(location, count, value);
-}
-
-void Context::programUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform4iv(location, count, value);
-}
-
-void Context::programUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform1uiv(location, count, value);
-}
-
-void Context::programUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform2uiv(location, count, value);
-}
-
-void Context::programUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform3uiv(location, count, value);
-}
-
-void Context::programUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform4uiv(location, count, value);
-}
-
-void Context::programUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform1fv(location, count, value);
-}
-
-void Context::programUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform2fv(location, count, value);
-}
-
-void Context::programUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform3fv(location, count, value);
-}
-
-void Context::programUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniform4fv(location, count, value);
-}
-
-void Context::programUniformMatrix2fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix2fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix3fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix3fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix4fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix4fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix2x3fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix2x3fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix3x2fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix3x2fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix2x4fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix2x4fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix4x2fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix4x2fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix3x4fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix3x4fv(location, count, transpose, value);
-}
-
-void Context::programUniformMatrix4x3fv(GLuint program,
- GLint location,
- GLsizei count,
- GLboolean transpose,
- const GLfloat *value)
-{
- Program *programObject = getProgram(program);
- ASSERT(programObject);
- programObject->setUniformMatrix4x3fv(location, count, transpose, value);
-}
-
-void Context::onTextureChange(const Texture *texture)
-{
- // Conservatively assume all textures are dirty.
- // TODO(jmadill): More fine-grained update.
- mGLState.setObjectDirty(GL_TEXTURE);
-}
-
-void Context::genProgramPipelines(GLsizei count, GLuint *pipelines)
-{
- for (int i = 0; i < count; i++)
- {
- pipelines[i] = createProgramPipeline();
- }
-}
-
-void Context::deleteProgramPipelines(GLsizei count, const GLuint *pipelines)
-{
- for (int i = 0; i < count; i++)
- {
- if (pipelines[i] != 0)
- {
- deleteProgramPipeline(pipelines[i]);
- }
- }
-}
-
-GLboolean Context::isProgramPipeline(GLuint pipeline)
-{
- if (pipeline == 0)
- {
- return GL_FALSE;
- }
-
- return (getProgramPipeline(pipeline) ? GL_TRUE : GL_FALSE);
-}
-
-} // namespace gl
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-03 08:43:47 +0000