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