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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Geoff Lang
  Date : 2013-09-24 13:56:32
  Hash : ce635695
  Message : Context now returns maximum texture levels per texture type, updated validation to validate mip level based on the texture target. TRAC #23630 Signed-off-by: Jamie Madill Signed-off-by: Shannon Woods

• src/libGLESv2/Context.h

• //
  // Copyright (c) 2002-2013 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 LIBGLESV2_CONTEXT_H_
  #define LIBGLESV2_CONTEXT_H_
  
  #ifndef GL_APICALL
  #define GL_APICALL
  #endif
  #include <GLES3/gl3.h>
  #include <GLES3/gl3ext.h>
  #include <GLES2/gl2.h>
  #include <GLES2/gl2ext.h>
  #define EGLAPI
  #include <EGL/egl.h>
  
  #include <string>
  #include <map>
  #include <unordered_map>
  
  #include "common/angleutils.h"
  #include "common/RefCountObject.h"
  #include "libGLESv2/HandleAllocator.h"
  #include "libGLESv2/angletypes.h"
  #include "libGLESv2/Constants.h"
  #include "libGLESv2/VertexAttribute.h"
  
  namespace rx
  {
  class Renderer;
  }
  
  namespace egl
  {
  class Display;
  class Surface;
  }
  
  namespace gl
  {
  class Shader;
  class Program;
  class ProgramBinary;
  class Texture;
  class Texture2D;
  class TextureCubeMap;
  class Texture3D;
  class Texture2DArray;
  class Framebuffer;
  class Renderbuffer;
  class RenderbufferStorage;
  class Colorbuffer;
  class Depthbuffer;
  class Stencilbuffer;
  class DepthStencilbuffer;
  class FenceNV;
  class FenceSync;
  class Query;
  class ResourceManager;
  class Buffer;
  class VertexAttribute;
  class VertexArray;
  class Sampler;
  
  enum QueryType
  {
      QUERY_ANY_SAMPLES_PASSED,
      QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE,
  
      QUERY_TYPE_COUNT
  };
  
  // Helper structure to store all raw state
  struct State
  {
      ColorF colorClearValue;
      GLclampf depthClearValue;
      int stencilClearValue;
  
      RasterizerState rasterizer;
      bool scissorTest;
      Rectangle scissor;
  
      BlendState blend;
      ColorF blendColor;
      bool sampleCoverage;
      GLclampf sampleCoverageValue;
      bool sampleCoverageInvert;
  
      DepthStencilState depthStencil;
      GLint stencilRef;
      GLint stencilBackRef;
  
      GLfloat lineWidth;
  
      GLenum generateMipmapHint;
      GLenum fragmentShaderDerivativeHint;
  
      Rectangle viewport;
      float zNear;
      float zFar;
  
      unsigned int activeSampler;   // Active texture unit selector - GL_TEXTURE0
      BindingPointer<Buffer> arrayBuffer;
      GLuint readFramebuffer;
      GLuint drawFramebuffer;
      BindingPointer<Renderbuffer> renderbuffer;
      GLuint currentProgram;
  
      VertexAttribCurrentValueData vertexAttribCurrentValues[MAX_VERTEX_ATTRIBS]; // From glVertexAttrib
      unsigned int vertexArray;
  
      BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS];
      BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];
      GLuint samplers[IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS];
  
      BindingPointer<Buffer> genericUniformBuffer;
      OffsetBindingPointer<Buffer> uniformBuffers[IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS];
  
      BindingPointer<Buffer> genericTransformFeedbackBuffer;
      OffsetBindingPointer<Buffer> transformFeedbackBuffers[IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS];
  
      BindingPointer<Buffer> copyReadBuffer;
      BindingPointer<Buffer> copyWriteBuffer;
  
      PixelUnpackState unpack;
      PixelPackState pack;
  };
  
  class Context
  {
    public:
      Context(int clientVersion, const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess);
  
      ~Context();
  
      void makeCurrent(egl::Surface *surface);
  
      virtual void markContextLost();
      bool isContextLost();
  
      // State manipulation
      void setClearColor(float red, float green, float blue, float alpha);
  
      void setClearDepth(float depth);
  
      void setClearStencil(int stencil);
  
      void setCullFace(bool enabled);
      bool isCullFaceEnabled() const;
  
      void setCullMode(GLenum mode);
  
      void setFrontFace(GLenum front);
  
      void setDepthTest(bool enabled);
      bool isDepthTestEnabled() const;
  
      void setDepthFunc(GLenum depthFunc);
  
      void setDepthRange(float zNear, float zFar);
      
      void setBlend(bool enabled);
      bool isBlendEnabled() const;
  
      void setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha);
      void setBlendColor(float red, float green, float blue, float alpha);
      void setBlendEquation(GLenum rgbEquation, GLenum alphaEquation);
  
      void setStencilTest(bool enabled);
      bool isStencilTestEnabled() const;
  
      void setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask);
      void setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask);
      void setStencilWritemask(GLuint stencilWritemask);
      void setStencilBackWritemask(GLuint stencilBackWritemask);
      void setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass);
      void setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass);
  
      void setPolygonOffsetFill(bool enabled);
      bool isPolygonOffsetFillEnabled() const;
  
      void setPolygonOffsetParams(GLfloat factor, GLfloat units);
  
      void setSampleAlphaToCoverage(bool enabled);
      bool isSampleAlphaToCoverageEnabled() const;
  
      void setSampleCoverage(bool enabled);
      bool isSampleCoverageEnabled() const;
  
      void setSampleCoverageParams(GLclampf value, bool invert);
  
      void setScissorTest(bool enabled);
      bool isScissorTestEnabled() const;
  
      void setDither(bool enabled);
      bool isDitherEnabled() const;
  
      void setLineWidth(GLfloat width);
  
      void setGenerateMipmapHint(GLenum hint);
      void setFragmentShaderDerivativeHint(GLenum hint);
  
      void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);
  
      void setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height);
      void getScissorParams(GLint *x, GLint *y, GLsizei *width, GLsizei *height);
  
      void setColorMask(bool red, bool green, bool blue, bool alpha);
      void setDepthMask(bool mask);
  
      void setActiveSampler(unsigned int active);
  
      GLuint getReadFramebufferHandle() const;
      GLuint getDrawFramebufferHandle() const;
      GLuint getRenderbufferHandle() const;
      GLuint getVertexArrayHandle() const;
      GLuint getSamplerHandle(GLuint textureUnit) const;
  
      GLuint getArrayBufferHandle() const;
  
      GLuint getActiveQuery(GLenum target) const;
  
      void setEnableVertexAttribArray(unsigned int attribNum, bool enabled);
      const VertexAttribute &getVertexAttribState(unsigned int attribNum) const;
      const VertexAttribCurrentValueData &getVertexAttribCurrentValue(unsigned int attribNum) const;
      void setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type,
                                bool normalized, bool pureInteger, GLsizei stride, const void *pointer);
      const void *getVertexAttribPointer(unsigned int attribNum) const;
  
      void setUnpackAlignment(GLint alignment);
      GLint getUnpackAlignment() const;
      const PixelUnpackState &getUnpackState() const;
  
      void setPackAlignment(GLint alignment);
      GLint getPackAlignment() const;
      const PixelPackState &getPackState() const;
  
      void setPackReverseRowOrder(bool reverseRowOrder);
      bool getPackReverseRowOrder() const;
  
      // 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();
      GLsync createFenceSync(GLenum condition);
  
      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 deleteFenceSync(GLsync fenceSync);
  
      // 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 buffer);
      void bindElementArrayBuffer(GLuint buffer);
      void bindTexture2D(GLuint texture);
      void bindTextureCubeMap(GLuint texture);
      void bindTexture3D(GLuint texture);
      void bindTexture2DArray(GLuint texture);
      void bindReadFramebuffer(GLuint framebuffer);
      void bindDrawFramebuffer(GLuint framebuffer);
      void bindRenderbuffer(GLuint renderbuffer);
      void bindVertexArray(GLuint vertexArray);
      void bindSampler(GLuint textureUnit, GLuint sampler);
      void bindGenericUniformBuffer(GLuint buffer);
      void bindIndexedUniformBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size);
      void bindGenericTransformFeedbackBuffer(GLuint buffer);
      void bindIndexedTransformFeedbackBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size);
      void bindCopyReadBuffer(GLuint buffer);
      void bindCopyWriteBuffer(GLuint buffer);
      void bindPixelPackBuffer(GLuint buffer);
      void bindPixelUnpackBuffer(GLuint buffer);
      void useProgram(GLuint program);
      void linkProgram(GLuint program);
      void setProgramBinary(GLuint program, const void *binary, GLint length);
  
      void beginQuery(GLenum target, GLuint query);
      void endQuery(GLenum target);
  
      void setFramebufferZero(Framebuffer *framebuffer);
  
      void setRenderbufferStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
  
      void setVertexAttribf(GLuint index, const GLfloat values[4]);
      void setVertexAttribu(GLuint index, const GLuint values[4]);
      void setVertexAttribi(GLuint index, const GLint values[4]);
      void setVertexAttribDivisor(GLuint index, GLuint divisor);
  
      void samplerParameteri(GLuint sampler, GLenum pname, GLint param);
      void samplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
      GLint getSamplerParameteri(GLuint sampler, GLenum pname);
      GLfloat getSamplerParameterf(GLuint sampler, GLenum pname);
  
      Buffer *getBuffer(GLuint handle);
      FenceNV *getFenceNV(GLuint handle);
      FenceSync *getFenceSync(GLsync handle) const;
      Shader *getShader(GLuint handle);
      Program *getProgram(GLuint handle);
      Texture *getTexture(GLuint handle);
      Framebuffer *getFramebuffer(GLuint handle);
      Renderbuffer *getRenderbuffer(GLuint handle);
      VertexArray *getVertexArray(GLuint handle) const;
      Sampler *getSampler(GLuint handle) const;
      Query *getQuery(GLuint handle, bool create, GLenum type);
  
      Buffer *getArrayBuffer();
      Buffer *getElementArrayBuffer();
      ProgramBinary *getCurrentProgramBinary();
      Texture2D *getTexture2D();
      TextureCubeMap *getTextureCubeMap();
      Texture3D *getTexture3D();
      Texture2DArray *getTexture2DArray();
      Buffer *getGenericUniformBuffer();
      Buffer *getGenericTransformFeedbackBuffer();
      Buffer *getCopyReadBuffer();
      Buffer *getCopyWriteBuffer();
      Buffer *getPixelPackBuffer();
      Buffer *getPixelUnpackBuffer();
      Texture *getSamplerTexture(unsigned int sampler, TextureType type);
      Framebuffer *getReadFramebuffer();
      Framebuffer *getDrawFramebuffer();
      VertexArray *getCurrentVertexArray() const;
  
      bool isSampler(GLuint samplerName) const;
  
      bool getBooleanv(GLenum pname, GLboolean *params);
      bool getFloatv(GLenum pname, GLfloat *params);
      bool getIntegerv(GLenum pname, GLint *params);
      bool getInteger64v(GLenum pname, GLint64 *params);
  
      bool getIndexedIntegerv(GLenum target, GLuint index, GLint *data);
      bool getIndexedInteger64v(GLenum target, GLuint index, GLint64 *data);
  
      bool getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams);
      bool getIndexedQueryParameterInfo(GLenum target, GLenum *type, unsigned int *numParams);
  
      void clear(GLbitfield mask);
      void clearBufferfv(GLenum buffer, int drawbuffer, const float *values);
      void clearBufferuiv(GLenum buffer, int drawbuffer, const unsigned int *values);
      void clearBufferiv(GLenum buffer, int drawbuffer, const int *values);
      void clearBufferfi(GLenum buffer, int drawbuffer, float depth, int stencil);
  
      void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);
      void drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances);
      void drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instances);
      void sync(bool block);   // flush/finish
  
      void recordInvalidEnum();
      void recordInvalidValue();
      void recordInvalidOperation();
      void recordOutOfMemory();
      void recordInvalidFramebufferOperation();
  
      GLenum getError();
      GLenum getResetStatus();
      virtual bool isResetNotificationEnabled();
  
      virtual int getClientVersion() const;
  
      int getMajorShaderModel() const;
      float getMaximumPointSize() const;
      unsigned int getMaximumCombinedTextureImageUnits() const;
      unsigned int getMaximumCombinedUniformBufferBindings() const;
      int getMaximumRenderbufferDimension() const;
      int getMaximum2DTextureDimension() const;
      int getMaximumCubeTextureDimension() const;
      int getMaximum3DTextureDimension() const;
      int getMaximum2DArrayTextureLayers() const;
      int getMaximum2DTextureLevel() const;
      int getMaximumCubeTextureLevel() const;
      int getMaximum3DTextureLevel() const;
      int getMaximum2DArrayTextureLevel() const;
      unsigned int getMaximumRenderTargets() const;
      GLsizei getMaxSupportedSamples() const;
      GLsizei getMaxSupportedFormatSamples(GLint internalFormat) const;
      GLsizei getNumSampleCounts(GLint internalFormat) const;
      void getSampleCounts(GLint internalFormat, GLsizei bufSize, GLint *params) const;
      unsigned int getMaxTransformFeedbackBufferBindings() const;
      GLintptr getUniformBufferOffsetAlignment() const;
      const char *getCombinedExtensionsString() const;
      const char *getExtensionString(const GLuint index) const;
      unsigned int getNumExtensions() const;
      const char *getRendererString() const;
      bool supportsEventQueries() const;
      bool supportsOcclusionQueries() const;
      bool supportsBGRATextures() const;
      bool supportsDXT1Textures() const;
      bool supportsDXT3Textures() const;
      bool supportsDXT5Textures() const;
      bool supportsFloat32Textures() const;
      bool supportsFloat32LinearFilter() const;
      bool supportsFloat32RenderableTextures() const;
      bool supportsFloat16Textures() const;
      bool supportsFloat16LinearFilter() const;
      bool supportsFloat16RenderableTextures() const;
      bool supportsLuminanceTextures() const;
      bool supportsLuminanceAlphaTextures() const;
      bool supportsDepthTextures() const;
      bool supports32bitIndices() const;
      bool supportsNonPower2Texture() const;
      bool supportsInstancing() const;
      bool supportsTextureFilterAnisotropy() const;
  
      bool getCurrentReadFormatType(GLint *internalFormat, GLenum *format, GLenum *type);
  
      float getTextureMaxAnisotropy() const;
  
      void blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
                           GLbitfield mask, GLenum filter);
  
      void invalidateFrameBuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments,
                                 GLint x, GLint y, GLsizei width, GLsizei height);
  
    private:
      DISALLOW_COPY_AND_ASSIGN(Context);
  
      bool applyRenderTarget(GLenum drawMode, bool ignoreViewport);
      void applyState(GLenum drawMode);
      void applyShaders();
      void applyTextures();
      void applyTextures(SamplerType type);
      bool applyUniformBuffers();
  
      void detachBuffer(GLuint buffer);
      void detachTexture(GLuint texture);
      void detachFramebuffer(GLuint framebuffer);
      void detachRenderbuffer(GLuint renderbuffer);
      void detachVertexArray(GLuint vertexArray);
      void detachSampler(GLuint sampler);
  
      Texture *getIncompleteTexture(TextureType type);
  
      bool skipDraw(GLenum drawMode);
  
      void initExtensionString();
      void initRendererString();
  
      rx::Renderer *const mRenderer;
  
      int mClientVersion;
  
      State mState;
  
      BindingPointer<Texture2D> mTexture2DZero;
      BindingPointer<TextureCubeMap> mTextureCubeMapZero;
      BindingPointer<Texture3D> mTexture3DZero;
      BindingPointer<Texture2DArray> mTexture2DArrayZero;
  
      typedef std::unordered_map<GLuint, Framebuffer*> FramebufferMap;
      FramebufferMap mFramebufferMap;
      HandleAllocator mFramebufferHandleAllocator;
  
      typedef std::unordered_map<GLuint, FenceNV*> FenceNVMap;
      FenceNVMap mFenceNVMap;
      HandleAllocator mFenceNVHandleAllocator;
  
      typedef std::unordered_map<GLuint, Query*> QueryMap;
      QueryMap mQueryMap;
      HandleAllocator mQueryHandleAllocator;
  
      typedef std::unordered_map<GLuint, VertexArray*> VertexArrayMap;
      VertexArrayMap mVertexArrayMap;
      HandleAllocator mVertexArrayHandleAllocator;
  
      std::vector<std::string> mExtensionStringList;
      const char *mCombinedExtensionsString;
      const char *mRendererString;
      
      BindingPointer<Texture> mIncompleteTextures[TEXTURE_TYPE_COUNT];
  
      // Recorded errors
      bool mInvalidEnum;
      bool mInvalidValue;
      bool mInvalidOperation;
      bool mOutOfMemory;
      bool mInvalidFramebufferOperation;
  
      // Current/lost context flags
      bool mHasBeenCurrent;
      bool mContextLost;
      GLenum mResetStatus;
      GLenum mResetStrategy;
      bool mRobustAccess;
  
      BindingPointer<ProgramBinary> mCurrentProgramBinary;
      Framebuffer *mBoundDrawFramebuffer;
  
      int mMajorShaderModel;
      float mMaximumPointSize;
      bool mSupportsVertexTexture;
      bool mSupportsNonPower2Texture;
      bool mSupportsInstancing;
      int  mMaxViewportDimension;
      int  mMaxRenderbufferDimension;
      int  mMax2DTextureDimension;
      int  mMaxCubeTextureDimension;
      int  mMax3DTextureDimension;
      int  mMax2DArrayTextureLayers;
      int  mMax2DTextureLevel;
      int  mMaxCubeTextureLevel;
      int  mMax3DTextureLevel;
      int  mMax2DArrayTextureLevel;
      float mMaxTextureAnisotropy;
      bool mSupportsEventQueries;
      bool mSupportsOcclusionQueries;
      bool mSupportsBGRATextures;
      bool mSupportsDXT1Textures;
      bool mSupportsDXT3Textures;
      bool mSupportsDXT5Textures;
      bool mSupportsFloat32Textures;
      bool mSupportsFloat32LinearFilter;
      bool mSupportsFloat32RenderableTextures;
      bool mSupportsFloat16Textures;
      bool mSupportsFloat16LinearFilter;
      bool mSupportsFloat16RenderableTextures;
      bool mSupportsLuminanceTextures;
      bool mSupportsLuminanceAlphaTextures;
      bool mSupportsDepthTextures;
      bool mSupports32bitIndices;
      bool mSupportsTextureFilterAnisotropy;
      int mNumCompressedTextureFormats;
  
      ResourceManager *mResourceManager;
  };
  }
  
  #endif   // INCLUDE_CONTEXT_H_