kc3-lang/angle/src/libANGLE/Texture.h

• Show log

  Commit

• Hash : dfde6abf
  Author :
  Date : 2016-06-09T07:07:18
  

  Context: Remove mutable gl::State getter.
  
  This will preserve layering - the API layer doesn't mutate the state
  directly, it passes the API call through to the Context. Is also
  removes the possiblity of any shenanigans of the Validation layer
  changing the GL state.
  
  Also, this CL refactors a few validation entry points to take
  ValidationContext instead of Context. ValidationContext will be the
  correct way to interact with the gl::Context in the Validation code.
  
  Finally, additional refactorings make ContextState a proper class with
  private data. This allows the ContextState itself to keep a mutable
  pointer to the gl::State, so ValidationContext can modify it if
  necessary (and it will be necessary for Framebuffer completeness
  caching).
  
  BUG=angleproject:1388
  
  Change-Id: I86ab3561573caa9535c8d1b8aad4ab3d0e7cd470
  Reviewed-on: https://chromium-review.googlesource.com/348954
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/Texture.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.
  //
  
  // Texture.h: Defines the gl::Texture class [OpenGL ES 2.0.24] section 3.7 page 63.
  
  #ifndef LIBANGLE_TEXTURE_H_
  #define LIBANGLE_TEXTURE_H_
  
  #include <vector>
  #include <map>
  
  #include "angle_gl.h"
  #include "common/debug.h"
  #include "libANGLE/Caps.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Constants.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/Image.h"
  #include "libANGLE/Stream.h"
  #include "libANGLE/angletypes.h"
  
  namespace egl
  {
  class Surface;
  class Stream;
  }
  
  namespace rx
  {
  class GLImplFactory;
  class TextureImpl;
  class TextureGL;
  }
  
  namespace gl
  {
  class ContextState;
  class Framebuffer;
  class Texture;
  
  bool IsMipmapFiltered(const SamplerState &samplerState);
  
  struct ImageDesc final
  {
      ImageDesc();
      ImageDesc(const Extents &size, GLenum internalFormat);
  
      ImageDesc(const ImageDesc &other) = default;
      ImageDesc &operator=(const ImageDesc &other) = default;
  
      Extents size;
      GLenum internalFormat;
  };
  
  struct SwizzleState final
  {
      SwizzleState();
      SwizzleState(GLenum red, GLenum green, GLenum blue, GLenum alpha);
      SwizzleState(const SwizzleState &other) = default;
      SwizzleState &operator=(const SwizzleState &other) = default;
  
      bool swizzleRequired() const;
  
      bool operator==(const SwizzleState &other) const;
      bool operator!=(const SwizzleState &other) const;
  
      GLenum swizzleRed;
      GLenum swizzleGreen;
      GLenum swizzleBlue;
      GLenum swizzleAlpha;
  };
  
  // State from Table 6.9 (state per texture object) in the OpenGL ES 3.0.2 spec.
  struct TextureState final : public angle::NonCopyable
  {
      TextureState(GLenum target);
  
      bool swizzleRequired() const;
      GLuint getEffectiveBaseLevel() const;
      GLuint getEffectiveMaxLevel() const;
  
      // Returns the value called "q" in the GLES 3.0.4 spec section 3.8.10.
      GLuint getMipmapMaxLevel() const;
  
      // Returns true if base level changed.
      bool setBaseLevel(GLuint baseLevel);
      void setMaxLevel(GLuint maxLevel);
  
      bool isCubeComplete() const;
      bool isSamplerComplete(const SamplerState &samplerState, const ContextState &data) const;
  
      const ImageDesc &getImageDesc(GLenum target, size_t level) const;
  
      GLenum getTarget() const { return mTarget; }
      const SwizzleState &getSwizzleState() const { return mSwizzleState; }
      const SamplerState &getSamplerState() const { return mSamplerState; }
      GLenum getUsage() const { return mUsage; }
  
    private:
      // Texture needs access to the ImageDesc functions.
      friend class Texture;
      // TODO(jmadill): Remove TextureGL from friends.
      friend class rx::TextureGL;
      friend bool operator==(const TextureState &a, const TextureState &b);
  
      bool computeSamplerCompleteness(const SamplerState &samplerState,
                                      const ContextState &data) const;
      bool computeMipmapCompleteness() const;
      bool computeLevelCompleteness(GLenum target, size_t level) const;
  
      GLenum getBaseImageTarget() const;
  
      void setImageDesc(GLenum target, size_t level, const ImageDesc &desc);
      void setImageDescChain(GLuint baselevel,
                             GLuint maxLevel,
                             Extents baseSize,
                             GLenum sizedInternalFormat);
      void clearImageDesc(GLenum target, size_t level);
      void clearImageDescs();
  
      const GLenum mTarget;
  
      SwizzleState mSwizzleState;
  
      SamplerState mSamplerState;
  
      GLuint mBaseLevel;
      GLuint mMaxLevel;
  
      bool mImmutableFormat;
      GLuint mImmutableLevels;
  
      // From GL_ANGLE_texture_usage
      GLenum mUsage;
  
      std::vector<ImageDesc> mImageDescs;
  
      struct SamplerCompletenessCache
      {
          SamplerCompletenessCache();
  
          bool cacheValid;
  
          // All values that affect sampler completeness that are not stored within
          // the texture itself
          SamplerState samplerState;
          bool filterable;
          GLint clientVersion;
          bool supportsNPOT;
  
          // Result of the sampler completeness with the above parameters
          bool samplerComplete;
      };
      mutable SamplerCompletenessCache mCompletenessCache;
  };
  
  bool operator==(const TextureState &a, const TextureState &b);
  bool operator!=(const TextureState &a, const TextureState &b);
  
  class Texture final : public egl::ImageSibling,
                        public FramebufferAttachmentObject,
                        public LabeledObject
  {
    public:
      Texture(rx::GLImplFactory *factory, GLuint id, GLenum target);
      ~Texture() override;
  
      void setLabel(const std::string &label) override;
      const std::string &getLabel() const override;
  
      GLenum getTarget() const;
  
      void setSwizzleRed(GLenum swizzleRed);
      GLenum getSwizzleRed() const;
  
      void setSwizzleGreen(GLenum swizzleGreen);
      GLenum getSwizzleGreen() const;
  
      void setSwizzleBlue(GLenum swizzleBlue);
      GLenum getSwizzleBlue() const;
  
      void setSwizzleAlpha(GLenum swizzleAlpha);
      GLenum getSwizzleAlpha() const;
  
      void setMinFilter(GLenum minFilter);
      GLenum getMinFilter() const;
  
      void setMagFilter(GLenum magFilter);
      GLenum getMagFilter() const;
  
      void setWrapS(GLenum wrapS);
      GLenum getWrapS() const;
  
      void setWrapT(GLenum wrapT);
      GLenum getWrapT() const;
  
      void setWrapR(GLenum wrapR);
      GLenum getWrapR() const;
  
      void setMaxAnisotropy(float maxAnisotropy);
      float getMaxAnisotropy() const;
  
      void setMinLod(GLfloat minLod);
      GLfloat getMinLod() const;
  
      void setMaxLod(GLfloat maxLod);
      GLfloat getMaxLod() const;
  
      void setCompareMode(GLenum compareMode);
      GLenum getCompareMode() const;
  
      void setCompareFunc(GLenum compareFunc);
      GLenum getCompareFunc() const;
  
      const SamplerState &getSamplerState() const;
  
      void setBaseLevel(GLuint baseLevel);
      GLuint getBaseLevel() const;
  
      void setMaxLevel(GLuint maxLevel);
      GLuint getMaxLevel() const;
  
      bool getImmutableFormat() const;
  
      GLuint getImmutableLevels() const;
  
      void setUsage(GLenum usage);
      GLenum getUsage() const;
  
      const TextureState &getTextureState() const;
  
      size_t getWidth(GLenum target, size_t level) const;
      size_t getHeight(GLenum target, size_t level) const;
      size_t getDepth(GLenum target, size_t level) const;
      GLenum getInternalFormat(GLenum target, size_t level) const;
  
      bool isMipmapComplete() const;
  
      Error setImage(const PixelUnpackState &unpackState,
                     GLenum target,
                     size_t level,
                     GLenum internalFormat,
                     const Extents &size,
                     GLenum format,
                     GLenum type,
                     const uint8_t *pixels);
      Error setSubImage(const PixelUnpackState &unpackState,
                        GLenum target,
                        size_t level,
                        const Box &area,
                        GLenum format,
                        GLenum type,
                        const uint8_t *pixels);
  
      Error setCompressedImage(const PixelUnpackState &unpackState,
                               GLenum target,
                               size_t level,
                               GLenum internalFormat,
                               const Extents &size,
                               size_t imageSize,
                               const uint8_t *pixels);
      Error setCompressedSubImage(const PixelUnpackState &unpackState,
                                  GLenum target,
                                  size_t level,
                                  const Box &area,
                                  GLenum format,
                                  size_t imageSize,
                                  const uint8_t *pixels);
  
      Error copyImage(GLenum target,
                      size_t level,
                      const Rectangle &sourceArea,
                      GLenum internalFormat,
                      const Framebuffer *source);
      Error copySubImage(GLenum target,
                         size_t level,
                         const Offset &destOffset,
                         const Rectangle &sourceArea,
                         const Framebuffer *source);
  
      Error setStorage(GLenum target, GLsizei levels, GLenum internalFormat, const Extents &size);
  
      Error setEGLImageTarget(GLenum target, egl::Image *imageTarget);
  
      Error generateMipmap();
  
      egl::Surface *getBoundSurface() const;
      egl::Stream *getBoundStream() const;
  
      rx::TextureImpl *getImplementation() { return mTexture; }
      const rx::TextureImpl *getImplementation() const { return mTexture; }
  
      // FramebufferAttachmentObject implementation
      Extents getAttachmentSize(const FramebufferAttachment::Target &target) const override;
      GLenum getAttachmentInternalFormat(const FramebufferAttachment::Target &target) const override;
      GLsizei getAttachmentSamples(const FramebufferAttachment::Target &target) const override;
  
      void onAttach() override;
      void onDetach() override;
      GLuint getId() const override;
  
    private:
      rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override;
  
      // ANGLE-only method, used internally
      friend class egl::Surface;
      void bindTexImageFromSurface(egl::Surface *surface);
      void releaseTexImageFromSurface();
  
      // ANGLE-only methods, used internally
      friend class egl::Stream;
      void bindStream(egl::Stream *stream);
      void releaseStream();
      void acquireImageFromStream(const egl::Stream::GLTextureDescription &desc);
      void releaseImageFromStream();
  
      TextureState mState;
      rx::TextureImpl *mTexture;
  
      std::string mLabel;
  
      void releaseTexImageInternal();
  
      egl::Surface *mBoundSurface;
      egl::Stream *mBoundStream;
  };
  
  inline bool operator==(const TextureState &a, const TextureState &b)
  {
      return a.mSwizzleState == b.mSwizzleState && a.mSamplerState == b.mSamplerState &&
             a.mBaseLevel == b.mBaseLevel && a.mMaxLevel == b.mMaxLevel &&
             a.mImmutableFormat == b.mImmutableFormat && a.mImmutableLevels == b.mImmutableLevels &&
             a.mUsage == b.mUsage;
  }
  
  inline bool operator!=(const TextureState &a, const TextureState &b)
  {
      return !(a == b);
  }
  }
  
  #endif   // LIBANGLE_TEXTURE_H_
  

Download