summaryrefslogtreecommitdiffstats
path: root/gfx/angle/checkout/src/libANGLE/Texture.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/Texture.h')
-rw-r--r--gfx/angle/checkout/src/libANGLE/Texture.h738
1 files changed, 738 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/Texture.h b/gfx/angle/checkout/src/libANGLE/Texture.h
new file mode 100644
index 0000000000..757f1a2e7e
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/Texture.h
@@ -0,0 +1,738 @@
+//
+// Copyright 2002 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// 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 <map>
+#include <vector>
+
+#include "angle_gl.h"
+#include "common/Optional.h"
+#include "common/debug.h"
+#include "common/utilities.h"
+#include "libANGLE/Caps.h"
+#include "libANGLE/Constants.h"
+#include "libANGLE/Debug.h"
+#include "libANGLE/Error.h"
+#include "libANGLE/FramebufferAttachment.h"
+#include "libANGLE/Image.h"
+#include "libANGLE/Observer.h"
+#include "libANGLE/Stream.h"
+#include "libANGLE/angletypes.h"
+#include "libANGLE/formatutils.h"
+
+namespace egl
+{
+class Surface;
+class Stream;
+} // namespace egl
+
+namespace rx
+{
+class GLImplFactory;
+class TextureImpl;
+class TextureGL;
+} // namespace rx
+
+namespace gl
+{
+class Framebuffer;
+class MemoryObject;
+class Sampler;
+class State;
+class Texture;
+
+constexpr GLuint kInitialMaxLevel = 1000;
+
+bool IsMipmapFiltered(GLenum minFilterMode);
+
+// Convert a given filter mode to nearest filtering.
+GLenum ConvertToNearestFilterMode(GLenum filterMode);
+
+// Convert a given filter mode to nearest mip filtering.
+GLenum ConvertToNearestMipFilterMode(GLenum filterMode);
+
+struct ImageDesc final
+{
+ ImageDesc();
+ ImageDesc(const Extents &size, const Format &format, const InitState initState);
+ ImageDesc(const Extents &size,
+ const Format &format,
+ const GLsizei samples,
+ const bool fixedSampleLocations,
+ const InitState initState);
+
+ ImageDesc(const ImageDesc &other) = default;
+ ImageDesc &operator=(const ImageDesc &other) = default;
+
+ GLint getMemorySize() const;
+
+ Extents size;
+ Format format;
+ GLsizei samples;
+ bool fixedSampleLocations;
+
+ // Needed for robust resource initialization.
+ InitState initState;
+};
+
+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.
+class TextureState final : private angle::NonCopyable
+{
+ public:
+ TextureState(TextureType type);
+ ~TextureState();
+
+ 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);
+ GLuint getBaseLevel() const { return mBaseLevel; }
+ bool setMaxLevel(GLuint maxLevel);
+ GLuint getMaxLevel() const { return mMaxLevel; }
+
+ bool isCubeComplete() const;
+
+ ANGLE_INLINE bool compatibleWithSamplerFormatForWebGL(SamplerFormat format,
+ const SamplerState &samplerState) const
+ {
+ if (!mCachedSamplerFormatValid ||
+ mCachedSamplerCompareMode != samplerState.getCompareMode())
+ {
+ mCachedSamplerFormat = computeRequiredSamplerFormat(samplerState);
+ mCachedSamplerCompareMode = samplerState.getCompareMode();
+ mCachedSamplerFormatValid = true;
+ }
+ // Incomplete textures are compatible with any sampler format.
+ return mCachedSamplerFormat == SamplerFormat::InvalidEnum || format == mCachedSamplerFormat;
+ }
+
+ const ImageDesc &getImageDesc(TextureTarget target, size_t level) const;
+ const ImageDesc &getImageDesc(const ImageIndex &imageIndex) const;
+
+ TextureType getType() const { return mType; }
+ const SwizzleState &getSwizzleState() const { return mSwizzleState; }
+ const SamplerState &getSamplerState() const { return mSamplerState; }
+ GLenum getUsage() const { return mUsage; }
+ bool hasProtectedContent() const { return mHasProtectedContent; }
+ GLenum getDepthStencilTextureMode() const { return mDepthStencilTextureMode; }
+ bool isStencilMode() const { return mDepthStencilTextureMode == GL_STENCIL_INDEX; }
+
+ bool hasBeenBoundAsImage() const { return mHasBeenBoundAsImage; }
+ bool is3DTextureAndHasBeenBoundAs2DImage() const { return mIs3DAndHasBeenBoundAs2DImage; }
+ bool hasBeenBoundAsAttachment() const { return mHasBeenBoundAsAttachment; }
+
+ gl::SrgbOverride getSRGBOverride() const { return mSrgbOverride; }
+
+ // Returns the desc of the base level. Only valid for cube-complete/mip-complete textures.
+ const ImageDesc &getBaseLevelDesc() const;
+ const ImageDesc &getLevelZeroDesc() const;
+
+ // GLES1 emulation: For GL_OES_draw_texture
+ void setCrop(const Rectangle &rect);
+ const Rectangle &getCrop() const;
+
+ // GLES1 emulation: Auto-mipmap generation is a texparameter
+ void setGenerateMipmapHint(GLenum hint);
+ GLenum getGenerateMipmapHint() const;
+
+ // Return the enabled mipmap level count.
+ GLuint getEnabledLevelCount() const;
+
+ bool getImmutableFormat() const { return mImmutableFormat; }
+ GLuint getImmutableLevels() const { return mImmutableLevels; }
+
+ const std::vector<ImageDesc> &getImageDescs() const { return mImageDescs; }
+
+ InitState getInitState() const { return mInitState; }
+
+ const OffsetBindingPointer<Buffer> &getBuffer() const { return mBuffer; }
+
+ const std::string &getLabel() const { return mLabel; }
+
+ private:
+ // Texture needs access to the ImageDesc functions.
+ friend class Texture;
+ friend bool operator==(const TextureState &a, const TextureState &b);
+
+ bool computeSamplerCompleteness(const SamplerState &samplerState, const State &state) const;
+ bool computeSamplerCompletenessForCopyImage(const SamplerState &samplerState,
+ const State &state) const;
+
+ bool computeMipmapCompleteness() const;
+ bool computeLevelCompleteness(TextureTarget target, size_t level) const;
+ SamplerFormat computeRequiredSamplerFormat(const SamplerState &samplerState) const;
+
+ TextureTarget getBaseImageTarget() const;
+
+ void setImageDesc(TextureTarget target, size_t level, const ImageDesc &desc);
+ void setImageDescChain(GLuint baselevel,
+ GLuint maxLevel,
+ Extents baseSize,
+ const Format &format,
+ InitState initState);
+ void setImageDescChainMultisample(Extents baseSize,
+ const Format &format,
+ GLsizei samples,
+ bool fixedSampleLocations,
+ InitState initState);
+
+ void clearImageDesc(TextureTarget target, size_t level);
+ void clearImageDescs();
+
+ const TextureType mType;
+
+ SwizzleState mSwizzleState;
+
+ SamplerState mSamplerState;
+
+ SrgbOverride mSrgbOverride;
+
+ GLuint mBaseLevel;
+ GLuint mMaxLevel;
+
+ GLenum mDepthStencilTextureMode;
+
+ bool mHasBeenBoundAsImage;
+ bool mIs3DAndHasBeenBoundAs2DImage;
+ bool mHasBeenBoundAsAttachment;
+
+ bool mImmutableFormat;
+ GLuint mImmutableLevels;
+
+ // From GL_ANGLE_texture_usage
+ GLenum mUsage;
+
+ // GL_EXT_protected_textures
+ bool mHasProtectedContent;
+
+ std::vector<ImageDesc> mImageDescs;
+
+ // GLES1 emulation: Texture crop rectangle
+ // For GL_OES_draw_texture
+ Rectangle mCropRect;
+
+ // GLES1 emulation: Generate-mipmap hint per texture
+ GLenum mGenerateMipmapHint;
+
+ // GL_OES_texture_buffer / GLES3.2
+ OffsetBindingPointer<Buffer> mBuffer;
+
+ InitState mInitState;
+
+ mutable SamplerFormat mCachedSamplerFormat;
+ mutable GLenum mCachedSamplerCompareMode;
+ mutable bool mCachedSamplerFormatValid;
+ std::string mLabel;
+};
+
+bool operator==(const TextureState &a, const TextureState &b);
+bool operator!=(const TextureState &a, const TextureState &b);
+
+class Texture final : public RefCountObject<TextureID>,
+ public egl::ImageSibling,
+ public LabeledObject
+{
+ public:
+ Texture(rx::GLImplFactory *factory, TextureID id, TextureType type);
+ ~Texture() override;
+
+ void onDestroy(const Context *context) override;
+
+ angle::Result setLabel(const Context *context, const std::string &label) override;
+
+ const std::string &getLabel() const override;
+
+ TextureType getType() const { return mState.mType; }
+
+ void setSwizzleRed(const Context *context, GLenum swizzleRed);
+ GLenum getSwizzleRed() const;
+
+ void setSwizzleGreen(const Context *context, GLenum swizzleGreen);
+ GLenum getSwizzleGreen() const;
+
+ void setSwizzleBlue(const Context *context, GLenum swizzleBlue);
+ GLenum getSwizzleBlue() const;
+
+ void setSwizzleAlpha(const Context *context, GLenum swizzleAlpha);
+ GLenum getSwizzleAlpha() const;
+
+ void setMinFilter(const Context *context, GLenum minFilter);
+ GLenum getMinFilter() const;
+
+ void setMagFilter(const Context *context, GLenum magFilter);
+ GLenum getMagFilter() const;
+
+ void setWrapS(const Context *context, GLenum wrapS);
+ GLenum getWrapS() const;
+
+ void setWrapT(const Context *context, GLenum wrapT);
+ GLenum getWrapT() const;
+
+ void setWrapR(const Context *context, GLenum wrapR);
+ GLenum getWrapR() const;
+
+ void setMaxAnisotropy(const Context *context, float maxAnisotropy);
+ float getMaxAnisotropy() const;
+
+ void setMinLod(const Context *context, GLfloat minLod);
+ GLfloat getMinLod() const;
+
+ void setMaxLod(const Context *context, GLfloat maxLod);
+ GLfloat getMaxLod() const;
+
+ void setCompareMode(const Context *context, GLenum compareMode);
+ GLenum getCompareMode() const;
+
+ void setCompareFunc(const Context *context, GLenum compareFunc);
+ GLenum getCompareFunc() const;
+
+ void setSRGBDecode(const Context *context, GLenum sRGBDecode);
+ GLenum getSRGBDecode() const;
+
+ void setSRGBOverride(const Context *context, GLenum sRGBOverride);
+ GLenum getSRGBOverride() const;
+
+ const SamplerState &getSamplerState() const;
+
+ angle::Result setBaseLevel(const Context *context, GLuint baseLevel);
+ GLuint getBaseLevel() const;
+
+ void setMaxLevel(const Context *context, GLuint maxLevel);
+ GLuint getMaxLevel() const;
+
+ void setDepthStencilTextureMode(const Context *context, GLenum mode);
+ GLenum getDepthStencilTextureMode() const;
+
+ bool getImmutableFormat() const;
+
+ GLuint getImmutableLevels() const;
+
+ void setUsage(const Context *context, GLenum usage);
+ GLenum getUsage() const;
+
+ void setProtectedContent(Context *context, bool hasProtectedContent);
+ bool hasProtectedContent() const override;
+
+ const TextureState &getState() const { return mState; }
+
+ void setBorderColor(const Context *context, const ColorGeneric &color);
+ const ColorGeneric &getBorderColor() const;
+
+ angle::Result setBuffer(const Context *context, gl::Buffer *buffer, GLenum internalFormat);
+ angle::Result setBufferRange(const Context *context,
+ gl::Buffer *buffer,
+ GLenum internalFormat,
+ GLintptr offset,
+ GLsizeiptr size);
+ const OffsetBindingPointer<Buffer> &getBuffer() const;
+
+ GLint getRequiredTextureImageUnits(const Context *context) const;
+
+ const TextureState &getTextureState() const;
+
+ const Extents &getExtents(TextureTarget target, size_t level) const;
+ size_t getWidth(TextureTarget target, size_t level) const;
+ size_t getHeight(TextureTarget target, size_t level) const;
+ size_t getDepth(TextureTarget target, size_t level) const;
+ GLsizei getSamples(TextureTarget target, size_t level) const;
+ bool getFixedSampleLocations(TextureTarget target, size_t level) const;
+ const Format &getFormat(TextureTarget target, size_t level) const;
+
+ // Returns the value called "q" in the GLES 3.0.4 spec section 3.8.10.
+ GLuint getMipmapMaxLevel() const;
+
+ bool isMipmapComplete() const;
+
+ angle::Result setImage(Context *context,
+ const PixelUnpackState &unpackState,
+ Buffer *unpackBuffer,
+ TextureTarget target,
+ GLint level,
+ GLenum internalFormat,
+ const Extents &size,
+ GLenum format,
+ GLenum type,
+ const uint8_t *pixels);
+ angle::Result setSubImage(Context *context,
+ const PixelUnpackState &unpackState,
+ Buffer *unpackBuffer,
+ TextureTarget target,
+ GLint level,
+ const Box &area,
+ GLenum format,
+ GLenum type,
+ const uint8_t *pixels);
+
+ angle::Result setCompressedImage(Context *context,
+ const PixelUnpackState &unpackState,
+ TextureTarget target,
+ GLint level,
+ GLenum internalFormat,
+ const Extents &size,
+ size_t imageSize,
+ const uint8_t *pixels);
+ angle::Result setCompressedSubImage(const Context *context,
+ const PixelUnpackState &unpackState,
+ TextureTarget target,
+ GLint level,
+ const Box &area,
+ GLenum format,
+ size_t imageSize,
+ const uint8_t *pixels);
+
+ angle::Result copyImage(Context *context,
+ TextureTarget target,
+ GLint level,
+ const Rectangle &sourceArea,
+ GLenum internalFormat,
+ Framebuffer *source);
+ angle::Result copySubImage(Context *context,
+ const ImageIndex &index,
+ const Offset &destOffset,
+ const Rectangle &sourceArea,
+ Framebuffer *source);
+
+ angle::Result copyRenderbufferSubData(Context *context,
+ const gl::Renderbuffer *srcBuffer,
+ GLint srcLevel,
+ GLint srcX,
+ GLint srcY,
+ GLint srcZ,
+ GLint dstLevel,
+ GLint dstX,
+ GLint dstY,
+ GLint dstZ,
+ GLsizei srcWidth,
+ GLsizei srcHeight,
+ GLsizei srcDepth);
+
+ angle::Result copyTextureSubData(Context *context,
+ const gl::Texture *srcTexture,
+ GLint srcLevel,
+ GLint srcX,
+ GLint srcY,
+ GLint srcZ,
+ GLint dstLevel,
+ GLint dstX,
+ GLint dstY,
+ GLint dstZ,
+ GLsizei srcWidth,
+ GLsizei srcHeight,
+ GLsizei srcDepth);
+
+ angle::Result copyTexture(Context *context,
+ TextureTarget target,
+ GLint level,
+ GLenum internalFormat,
+ GLenum type,
+ GLint sourceLevel,
+ bool unpackFlipY,
+ bool unpackPremultiplyAlpha,
+ bool unpackUnmultiplyAlpha,
+ Texture *source);
+ angle::Result copySubTexture(const Context *context,
+ TextureTarget target,
+ GLint level,
+ const Offset &destOffset,
+ GLint sourceLevel,
+ const Box &sourceBox,
+ bool unpackFlipY,
+ bool unpackPremultiplyAlpha,
+ bool unpackUnmultiplyAlpha,
+ Texture *source);
+ angle::Result copyCompressedTexture(Context *context, const Texture *source);
+
+ angle::Result setStorage(Context *context,
+ TextureType type,
+ GLsizei levels,
+ GLenum internalFormat,
+ const Extents &size);
+
+ angle::Result setStorageMultisample(Context *context,
+ TextureType type,
+ GLsizei samplesIn,
+ GLint internalformat,
+ const Extents &size,
+ bool fixedSampleLocations);
+
+ angle::Result setStorageExternalMemory(Context *context,
+ TextureType type,
+ GLsizei levels,
+ GLenum internalFormat,
+ const Extents &size,
+ MemoryObject *memoryObject,
+ GLuint64 offset,
+ GLbitfield createFlags,
+ GLbitfield usageFlags,
+ const void *imageCreateInfoPNext);
+
+ angle::Result setImageExternal(Context *context,
+ TextureTarget target,
+ GLint level,
+ GLenum internalFormat,
+ const Extents &size,
+ GLenum format,
+ GLenum type);
+
+ angle::Result setEGLImageTarget(Context *context, TextureType type, egl::Image *imageTarget);
+
+ angle::Result setStorageEGLImageTarget(Context *context,
+ TextureType type,
+ egl::Image *image,
+ const GLint *attrib_list);
+
+ angle::Result generateMipmap(Context *context);
+
+ void onBindAsImageTexture();
+ void onBind3DTextureAs2DImage();
+
+ egl::Surface *getBoundSurface() const;
+ egl::Stream *getBoundStream() const;
+
+ GLint getMemorySize() const;
+ GLint getLevelMemorySize(TextureTarget target, GLint level) const;
+
+ void signalDirtyStorage(InitState initState);
+
+ bool isSamplerComplete(const Context *context, const Sampler *optionalSampler);
+ bool isSamplerCompleteForCopyImage(const Context *context,
+ const Sampler *optionalSampler) const;
+
+ GLenum getImplementationColorReadFormat(const Context *context) const;
+ GLenum getImplementationColorReadType(const Context *context) const;
+
+ bool isCompressedFormatEmulated(const Context *context,
+ TextureTarget target,
+ GLint level) const;
+
+ // We pass the pack buffer and state explicitly so they can be overridden during capture.
+ angle::Result getTexImage(const Context *context,
+ const PixelPackState &packState,
+ Buffer *packBuffer,
+ TextureTarget target,
+ GLint level,
+ GLenum format,
+ GLenum type,
+ void *pixels);
+
+ angle::Result getCompressedTexImage(const Context *context,
+ const PixelPackState &packState,
+ Buffer *packBuffer,
+ TextureTarget target,
+ GLint level,
+ void *pixels);
+
+ rx::TextureImpl *getImplementation() const { return mTexture; }
+
+ // FramebufferAttachmentObject implementation
+ Extents getAttachmentSize(const ImageIndex &imageIndex) const override;
+ Format getAttachmentFormat(GLenum binding, const ImageIndex &imageIndex) const override;
+ GLsizei getAttachmentSamples(const ImageIndex &imageIndex) const override;
+ bool isRenderable(const Context *context,
+ GLenum binding,
+ const ImageIndex &imageIndex) const override;
+
+ bool getAttachmentFixedSampleLocations(const ImageIndex &imageIndex) const;
+
+ // GLES1 emulation
+ void setCrop(const Rectangle &rect);
+ const Rectangle &getCrop() const;
+ void setGenerateMipmapHint(GLenum generate);
+ GLenum getGenerateMipmapHint() const;
+
+ void onAttach(const Context *context, rx::Serial framebufferSerial) override;
+ void onDetach(const Context *context, rx::Serial framebufferSerial) override;
+
+ // Used specifically for FramebufferAttachmentObject.
+ GLuint getId() const override;
+
+ GLuint getNativeID() const;
+
+ // Needed for robust resource init.
+ angle::Result ensureInitialized(const Context *context);
+ InitState initState(GLenum binding, const ImageIndex &imageIndex) const override;
+ InitState initState() const { return mState.mInitState; }
+ void setInitState(GLenum binding, const ImageIndex &imageIndex, InitState initState) override;
+ void setInitState(InitState initState);
+
+ bool isBoundToFramebuffer(rx::Serial framebufferSerial) const
+ {
+ for (size_t index = 0; index < mBoundFramebufferSerials.size(); ++index)
+ {
+ if (mBoundFramebufferSerials[index] == framebufferSerial)
+ return true;
+ }
+
+ return false;
+ }
+
+ bool isDepthOrStencil() const
+ {
+ return mState.getBaseLevelDesc().format.info->isDepthOrStencil();
+ }
+
+ enum DirtyBitType
+ {
+ // Sampler state
+ DIRTY_BIT_MIN_FILTER,
+ DIRTY_BIT_MAG_FILTER,
+ DIRTY_BIT_WRAP_S,
+ DIRTY_BIT_WRAP_T,
+ DIRTY_BIT_WRAP_R,
+ DIRTY_BIT_MAX_ANISOTROPY,
+ DIRTY_BIT_MIN_LOD,
+ DIRTY_BIT_MAX_LOD,
+ DIRTY_BIT_COMPARE_MODE,
+ DIRTY_BIT_COMPARE_FUNC,
+ DIRTY_BIT_SRGB_DECODE,
+ DIRTY_BIT_SRGB_OVERRIDE,
+ DIRTY_BIT_BORDER_COLOR,
+
+ // Texture state
+ DIRTY_BIT_SWIZZLE_RED,
+ DIRTY_BIT_SWIZZLE_GREEN,
+ DIRTY_BIT_SWIZZLE_BLUE,
+ DIRTY_BIT_SWIZZLE_ALPHA,
+ DIRTY_BIT_BASE_LEVEL,
+ DIRTY_BIT_MAX_LEVEL,
+ DIRTY_BIT_DEPTH_STENCIL_TEXTURE_MODE,
+
+ // Image state
+ DIRTY_BIT_BOUND_AS_IMAGE,
+ DIRTY_BIT_BOUND_AS_ATTACHMENT,
+
+ // Misc
+ DIRTY_BIT_USAGE,
+ DIRTY_BIT_IMPLEMENTATION,
+
+ DIRTY_BIT_COUNT,
+ };
+ using DirtyBits = angle::BitSet<DIRTY_BIT_COUNT>;
+
+ angle::Result syncState(const Context *context, Command source);
+ bool hasAnyDirtyBit() const { return mDirtyBits.any(); }
+ bool hasAnyDirtyBitExcludingBoundAsAttachmentBit() const
+ {
+ static constexpr DirtyBits kBoundAsAttachment = DirtyBits({DIRTY_BIT_BOUND_AS_ATTACHMENT});
+ return mDirtyBits.any() && mDirtyBits != kBoundAsAttachment;
+ }
+
+ // ObserverInterface implementation.
+ void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
+
+ private:
+ rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override;
+
+ // ANGLE-only method, used internally
+ friend class egl::Surface;
+ angle::Result bindTexImageFromSurface(Context *context, egl::Surface *surface);
+ angle::Result releaseTexImageFromSurface(const Context *context);
+
+ // ANGLE-only methods, used internally
+ friend class egl::Stream;
+ void bindStream(egl::Stream *stream);
+ void releaseStream();
+ angle::Result acquireImageFromStream(const Context *context,
+ const egl::Stream::GLTextureDescription &desc);
+ angle::Result releaseImageFromStream(const Context *context);
+
+ void invalidateCompletenessCache() const;
+ angle::Result releaseTexImageInternal(Context *context);
+
+ bool doesSubImageNeedInit(const Context *context,
+ const ImageIndex &imageIndex,
+ const Box &area) const;
+ angle::Result ensureSubImageInitialized(const Context *context,
+ const ImageIndex &imageIndex,
+ const Box &area);
+
+ angle::Result handleMipmapGenerationHint(Context *context, int level);
+
+ angle::Result setEGLImageTargetImpl(Context *context,
+ TextureType type,
+ GLuint levels,
+ egl::Image *imageTarget);
+
+ void signalDirtyState(size_t dirtyBit);
+
+ TextureState mState;
+ DirtyBits mDirtyBits;
+ rx::TextureImpl *mTexture;
+ angle::ObserverBinding mImplObserver;
+ // For EXT_texture_buffer, observes buffer changes.
+ angle::ObserverBinding mBufferObserver;
+
+ egl::Surface *mBoundSurface;
+ egl::Stream *mBoundStream;
+
+ // We track all the serials of the Framebuffers this texture is attached to. Note that this
+ // allows duplicates because different ranges of a Texture can be bound to the same Framebuffer.
+ // For the purposes of depth-stencil loops, a simple "isBound" check works fine. For color
+ // attachment Feedback Loop checks we then need to check further to see when a Texture is bound
+ // to mulitple bindings that the bindings don't overlap.
+ static constexpr uint32_t kFastFramebufferSerialCount = 8;
+ angle::FastVector<rx::Serial, kFastFramebufferSerialCount> mBoundFramebufferSerials;
+
+ struct SamplerCompletenessCache
+ {
+ SamplerCompletenessCache();
+
+ // Context used to generate this cache entry
+ ContextID context;
+
+ // All values that affect sampler completeness that are not stored within
+ // the texture itself
+ SamplerState samplerState;
+
+ // Result of the sampler completeness with the above parameters
+ bool samplerComplete;
+ };
+
+ mutable SamplerCompletenessCache mCompletenessCache;
+};
+
+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);
+}
+} // namespace gl
+
+#endif // LIBANGLE_TEXTURE_H_
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-10 16:55:01 +0000