diff options
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/Texture.cpp')
-rw-r--r-- | src/3rdparty/angle/src/libANGLE/Texture.cpp | 1509 |
1 files changed, 1054 insertions, 455 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/Texture.cpp b/src/3rdparty/angle/src/libANGLE/Texture.cpp index 5ef6762d3d..da92e65916 100644 --- a/src/3rdparty/angle/src/libANGLE/Texture.cpp +++ b/src/3rdparty/angle/src/libANGLE/Texture.cpp @@ -12,66 +12,571 @@ #include "common/utilities.h" #include "libANGLE/Config.h" #include "libANGLE/Context.h" -#include "libANGLE/Data.h" +#include "libANGLE/ContextState.h" #include "libANGLE/Image.h" #include "libANGLE/Surface.h" #include "libANGLE/formatutils.h" +#include "libANGLE/renderer/GLImplFactory.h" +#include "libANGLE/renderer/TextureImpl.h" namespace gl { -bool IsMipmapFiltered(const gl::SamplerState &samplerState) +namespace +{ +bool IsPointSampled(const SamplerState &samplerState) +{ + return (samplerState.magFilter == GL_NEAREST && + (samplerState.minFilter == GL_NEAREST || + samplerState.minFilter == GL_NEAREST_MIPMAP_NEAREST)); +} + +size_t GetImageDescIndex(GLenum target, size_t level) +{ + return IsCubeMapTextureTarget(target) ? ((level * 6) + CubeMapTextureTargetToLayerIndex(target)) + : level; +} + +ImageIndex GetImageIndexFromDescIndex(GLenum target, size_t descIndex) +{ + if (target == GL_TEXTURE_CUBE_MAP) + { + size_t faceIndex = descIndex % 6; + size_t mipIndex = descIndex / 6; + return ImageIndex::MakeCube(LayerIndexToCubeMapTextureTarget(faceIndex), + static_cast<GLint>(mipIndex)); + } + + return ImageIndex::MakeGeneric(target, static_cast<GLint>(descIndex)); +} + +InitState DetermineInitState(const Context *context, const uint8_t *pixels) +{ + // Can happen in tests. + if (!context || !context->isRobustResourceInitEnabled()) + return InitState::Initialized; + + const auto &glState = context->getGLState(); + return (pixels == nullptr && glState.getTargetBuffer(gl::BufferBinding::PixelUnpack) == nullptr) + ? InitState::MayNeedInit + : InitState::Initialized; +} + +} // namespace + +bool IsMipmapFiltered(const SamplerState &samplerState) { switch (samplerState.minFilter) { - case GL_NEAREST: - case GL_LINEAR: + case GL_NEAREST: + case GL_LINEAR: + return false; + case GL_NEAREST_MIPMAP_NEAREST: + case GL_LINEAR_MIPMAP_NEAREST: + case GL_NEAREST_MIPMAP_LINEAR: + case GL_LINEAR_MIPMAP_LINEAR: + return true; + default: + UNREACHABLE(); + return false; + } +} + +SwizzleState::SwizzleState() + : swizzleRed(GL_INVALID_INDEX), + swizzleGreen(GL_INVALID_INDEX), + swizzleBlue(GL_INVALID_INDEX), + swizzleAlpha(GL_INVALID_INDEX) +{ +} + +SwizzleState::SwizzleState(GLenum red, GLenum green, GLenum blue, GLenum alpha) + : swizzleRed(red), swizzleGreen(green), swizzleBlue(blue), swizzleAlpha(alpha) +{ +} + +bool SwizzleState::swizzleRequired() const +{ + return swizzleRed != GL_RED || swizzleGreen != GL_GREEN || swizzleBlue != GL_BLUE || + swizzleAlpha != GL_ALPHA; +} + +bool SwizzleState::operator==(const SwizzleState &other) const +{ + return swizzleRed == other.swizzleRed && swizzleGreen == other.swizzleGreen && + swizzleBlue == other.swizzleBlue && swizzleAlpha == other.swizzleAlpha; +} + +bool SwizzleState::operator!=(const SwizzleState &other) const +{ + return !(*this == other); +} + +TextureState::TextureState(GLenum target) + : mTarget(target), + mSwizzleState(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA), + mSamplerState(SamplerState::CreateDefaultForTarget(target)), + mBaseLevel(0), + mMaxLevel(1000), + mDepthStencilTextureMode(GL_DEPTH_COMPONENT), + mImmutableFormat(false), + mImmutableLevels(0), + mUsage(GL_NONE), + mImageDescs((IMPLEMENTATION_MAX_TEXTURE_LEVELS + 1) * + (target == GL_TEXTURE_CUBE_MAP ? 6 : 1)), + mInitState(InitState::MayNeedInit) +{ +} + +TextureState::~TextureState() +{ +} + +bool TextureState::swizzleRequired() const +{ + return mSwizzleState.swizzleRequired(); +} + +GLuint TextureState::getEffectiveBaseLevel() const +{ + if (mImmutableFormat) + { + // GLES 3.0.4 section 3.8.10 + return std::min(mBaseLevel, mImmutableLevels - 1); + } + // Some classes use the effective base level to index arrays with level data. By clamping the + // effective base level to max levels these arrays need just one extra item to store properties + // that should be returned for all out-of-range base level values, instead of needing special + // handling for out-of-range base levels. + return std::min(mBaseLevel, static_cast<GLuint>(IMPLEMENTATION_MAX_TEXTURE_LEVELS)); +} + +GLuint TextureState::getEffectiveMaxLevel() const +{ + if (mImmutableFormat) + { + // GLES 3.0.4 section 3.8.10 + GLuint clampedMaxLevel = std::max(mMaxLevel, getEffectiveBaseLevel()); + clampedMaxLevel = std::min(clampedMaxLevel, mImmutableLevels - 1); + return clampedMaxLevel; + } + return mMaxLevel; +} + +GLuint TextureState::getMipmapMaxLevel() const +{ + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel()); + GLuint expectedMipLevels = 0; + if (mTarget == GL_TEXTURE_3D) + { + const int maxDim = std::max(std::max(baseImageDesc.size.width, baseImageDesc.size.height), + baseImageDesc.size.depth); + expectedMipLevels = static_cast<GLuint>(log2(maxDim)); + } + else + { + expectedMipLevels = static_cast<GLuint>( + log2(std::max(baseImageDesc.size.width, baseImageDesc.size.height))); + } + + return std::min<GLuint>(getEffectiveBaseLevel() + expectedMipLevels, getEffectiveMaxLevel()); +} + +bool TextureState::setBaseLevel(GLuint baseLevel) +{ + if (mBaseLevel != baseLevel) + { + mBaseLevel = baseLevel; + return true; + } + return false; +} + +bool TextureState::setMaxLevel(GLuint maxLevel) +{ + if (mMaxLevel != maxLevel) + { + mMaxLevel = maxLevel; + return true; + } + + return false; +} + +// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81. +// According to [OpenGL ES 3.0.5] section 3.8.13 Texture Completeness page 160 any +// per-level checks begin at the base-level. +// For OpenGL ES2 the base level is always zero. +bool TextureState::isCubeComplete() const +{ + ASSERT(mTarget == GL_TEXTURE_CUBE_MAP); + + const ImageDesc &baseImageDesc = + getImageDesc(FirstCubeMapTextureTarget, getEffectiveBaseLevel()); + if (baseImageDesc.size.width == 0 || baseImageDesc.size.width != baseImageDesc.size.height) + { + return false; + } + + for (GLenum face = FirstCubeMapTextureTarget + 1; face <= LastCubeMapTextureTarget; face++) + { + const ImageDesc &faceImageDesc = getImageDesc(face, getEffectiveBaseLevel()); + if (faceImageDesc.size.width != baseImageDesc.size.width || + faceImageDesc.size.height != baseImageDesc.size.height || + !Format::SameSized(faceImageDesc.format, baseImageDesc.format)) + { + return false; + } + } + + return true; +} + +bool TextureState::computeSamplerCompleteness(const SamplerState &samplerState, + const ContextState &data) const +{ + if (mBaseLevel > mMaxLevel) + { + return false; + } + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel()); + if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 || + baseImageDesc.size.depth == 0) + { + return false; + } + // The cases where the texture is incomplete because base level is out of range should be + // handled by the above condition. + ASSERT(mBaseLevel < IMPLEMENTATION_MAX_TEXTURE_LEVELS || mImmutableFormat); + + if (mTarget == GL_TEXTURE_CUBE_MAP && baseImageDesc.size.width != baseImageDesc.size.height) + { + return false; + } + + // According to es 3.1 spec, texture is justified as incomplete if sized internalformat is + // unfilterable(table 20.11) and filter is not GL_NEAREST(8.16). The default value of minFilter + // is NEAREST_MIPMAP_LINEAR and magFilter is LINEAR(table 20.11,). For multismaple texture, + // filter state of multisample texture is ignored(11.1.3.3). So it shouldn't be judged as + // incomplete texture. So, we ignore filtering for multisample texture completeness here. + if (mTarget != GL_TEXTURE_2D_MULTISAMPLE && + !baseImageDesc.format.info->filterSupport(data.getClientVersion(), data.getExtensions()) && + !IsPointSampled(samplerState)) + { return false; - case GL_NEAREST_MIPMAP_NEAREST: - case GL_LINEAR_MIPMAP_NEAREST: - case GL_NEAREST_MIPMAP_LINEAR: - case GL_LINEAR_MIPMAP_LINEAR: + } + bool npotSupport = data.getExtensions().textureNPOT || data.getClientMajorVersion() >= 3; + if (!npotSupport) + { + if ((samplerState.wrapS != GL_CLAMP_TO_EDGE && !isPow2(baseImageDesc.size.width)) || + (samplerState.wrapT != GL_CLAMP_TO_EDGE && !isPow2(baseImageDesc.size.height))) + { + return false; + } + } + + if (mTarget != GL_TEXTURE_2D_MULTISAMPLE && IsMipmapFiltered(samplerState)) + { + if (!npotSupport) + { + if (!isPow2(baseImageDesc.size.width) || !isPow2(baseImageDesc.size.height)) + { + return false; + } + } + + if (!computeMipmapCompleteness()) + { + return false; + } + } + else + { + if (mTarget == GL_TEXTURE_CUBE_MAP && !isCubeComplete()) + { + return false; + } + } + + // From GL_OES_EGL_image_external_essl3: If state is present in a sampler object bound to a + // texture unit that would have been rejected by a call to TexParameter* for the texture bound + // to that unit, the behavior of the implementation is as if the texture were incomplete. For + // example, if TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to anything but CLAMP_TO_EDGE on the + // sampler object bound to a texture unit and the texture bound to that unit is an external + // texture, the texture will be considered incomplete. + // Sampler object state which does not affect sampling for the type of texture bound to a + // texture unit, such as TEXTURE_WRAP_R for an external texture, does not affect completeness. + if (mTarget == GL_TEXTURE_EXTERNAL_OES) + { + if (samplerState.wrapS != GL_CLAMP_TO_EDGE || samplerState.wrapT != GL_CLAMP_TO_EDGE) + { + return false; + } + + if (samplerState.minFilter != GL_LINEAR && samplerState.minFilter != GL_NEAREST) + { + return false; + } + } + + // OpenGLES 3.0.2 spec section 3.8.13 states that a texture is not mipmap complete if: + // The internalformat specified for the texture arrays is a sized internal depth or + // depth and stencil format (see table 3.13), the value of TEXTURE_COMPARE_- + // MODE is NONE, and either the magnification filter is not NEAREST or the mini- + // fication filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST. + if (mTarget != GL_TEXTURE_2D_MULTISAMPLE && baseImageDesc.format.info->depthBits > 0 && + data.getClientMajorVersion() >= 3) + { + // Note: we restrict this validation to sized types. For the OES_depth_textures + // extension, due to some underspecification problems, we must allow linear filtering + // for legacy compatibility with WebGL 1. + // See http://crbug.com/649200 + if (samplerState.compareMode == GL_NONE && baseImageDesc.format.info->sized) + { + if ((samplerState.minFilter != GL_NEAREST && + samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST) || + samplerState.magFilter != GL_NEAREST) + { + return false; + } + } + } + + return true; +} + +bool TextureState::computeMipmapCompleteness() const +{ + const GLuint maxLevel = getMipmapMaxLevel(); + + for (GLuint level = getEffectiveBaseLevel(); level <= maxLevel; level++) + { + if (mTarget == GL_TEXTURE_CUBE_MAP) + { + for (GLenum face = FirstCubeMapTextureTarget; face <= LastCubeMapTextureTarget; face++) + { + if (!computeLevelCompleteness(face, level)) + { + return false; + } + } + } + else + { + if (!computeLevelCompleteness(mTarget, level)) + { + return false; + } + } + } + + return true; +} + +bool TextureState::computeLevelCompleteness(GLenum target, size_t level) const +{ + ASSERT(level < IMPLEMENTATION_MAX_TEXTURE_LEVELS); + + if (mImmutableFormat) + { return true; - default: UNREACHABLE(); + } + + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel()); + if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 || + baseImageDesc.size.depth == 0) + { return false; } + + const ImageDesc &levelImageDesc = getImageDesc(target, level); + if (levelImageDesc.size.width == 0 || levelImageDesc.size.height == 0 || + levelImageDesc.size.depth == 0) + { + return false; + } + + if (!Format::SameSized(levelImageDesc.format, baseImageDesc.format)) + { + return false; + } + + ASSERT(level >= getEffectiveBaseLevel()); + const size_t relativeLevel = level - getEffectiveBaseLevel(); + if (levelImageDesc.size.width != std::max(1, baseImageDesc.size.width >> relativeLevel)) + { + return false; + } + + if (levelImageDesc.size.height != std::max(1, baseImageDesc.size.height >> relativeLevel)) + { + return false; + } + + if (mTarget == GL_TEXTURE_3D) + { + if (levelImageDesc.size.depth != std::max(1, baseImageDesc.size.depth >> relativeLevel)) + { + return false; + } + } + else if (mTarget == GL_TEXTURE_2D_ARRAY) + { + if (levelImageDesc.size.depth != baseImageDesc.size.depth) + { + return false; + } + } + + return true; +} + +GLenum TextureState::getBaseImageTarget() const +{ + return mTarget == GL_TEXTURE_CUBE_MAP ? FirstCubeMapTextureTarget : mTarget; +} + +ImageDesc::ImageDesc() + : ImageDesc(Extents(0, 0, 0), Format::Invalid(), 0, GL_TRUE, InitState::Initialized) +{ } -bool IsPointSampled(const gl::SamplerState &samplerState) +ImageDesc::ImageDesc(const Extents &size, const Format &format, const InitState initState) + : size(size), format(format), samples(0), fixedSampleLocations(GL_TRUE), initState(initState) { - return (samplerState.magFilter == GL_NEAREST && (samplerState.minFilter == GL_NEAREST || samplerState.minFilter == GL_NEAREST_MIPMAP_NEAREST)); } -static size_t GetImageDescIndex(GLenum target, size_t level) +ImageDesc::ImageDesc(const Extents &size, + const Format &format, + const GLsizei samples, + const bool fixedSampleLocations, + const InitState initState) + : size(size), + format(format), + samples(samples), + fixedSampleLocations(fixedSampleLocations), + initState(initState) { - return IsCubeMapTextureTarget(target) ? ((level * 6) + CubeMapTextureTargetToLayerIndex(target)) : level; } -Texture::Texture(rx::TextureImpl *impl, GLuint id, GLenum target) +const ImageDesc &TextureState::getImageDesc(GLenum target, size_t level) const +{ + size_t descIndex = GetImageDescIndex(target, level); + ASSERT(descIndex < mImageDescs.size()); + return mImageDescs[descIndex]; +} + +void TextureState::setImageDesc(GLenum target, size_t level, const ImageDesc &desc) +{ + size_t descIndex = GetImageDescIndex(target, level); + ASSERT(descIndex < mImageDescs.size()); + mImageDescs[descIndex] = desc; + if (desc.initState == InitState::MayNeedInit) + { + mInitState = InitState::MayNeedInit; + } +} + +const ImageDesc &TextureState::getImageDesc(const ImageIndex &imageIndex) const +{ + return getImageDesc(imageIndex.type, imageIndex.mipIndex); +} + +void TextureState::setImageDescChain(GLuint baseLevel, + GLuint maxLevel, + Extents baseSize, + const Format &format, + InitState initState) +{ + for (GLuint level = baseLevel; level <= maxLevel; level++) + { + int relativeLevel = (level - baseLevel); + Extents levelSize(std::max<int>(baseSize.width >> relativeLevel, 1), + std::max<int>(baseSize.height >> relativeLevel, 1), + (mTarget == GL_TEXTURE_2D_ARRAY) + ? baseSize.depth + : std::max<int>(baseSize.depth >> relativeLevel, 1)); + ImageDesc levelInfo(levelSize, format, initState); + + if (mTarget == GL_TEXTURE_CUBE_MAP) + { + for (GLenum face = FirstCubeMapTextureTarget; face <= LastCubeMapTextureTarget; face++) + { + setImageDesc(face, level, levelInfo); + } + } + else + { + setImageDesc(mTarget, level, levelInfo); + } + } +} + +void TextureState::setImageDescChainMultisample(Extents baseSize, + const Format &format, + GLsizei samples, + bool fixedSampleLocations, + InitState initState) +{ + ASSERT(mTarget == GL_TEXTURE_2D_MULTISAMPLE); + ImageDesc levelInfo(baseSize, format, samples, fixedSampleLocations, initState); + setImageDesc(mTarget, 0, levelInfo); +} + +void TextureState::clearImageDesc(GLenum target, size_t level) +{ + setImageDesc(target, level, ImageDesc()); +} + +void TextureState::clearImageDescs() +{ + for (size_t descIndex = 0; descIndex < mImageDescs.size(); descIndex++) + { + mImageDescs[descIndex] = ImageDesc(); + } +} + +Texture::Texture(rx::GLImplFactory *factory, GLuint id, GLenum target) : egl::ImageSibling(id), - mTexture(impl), + mState(target), + mTexture(factory->createTexture(mState)), mLabel(), - mTextureState(), - mTarget(target), - mImageDescs(IMPLEMENTATION_MAX_TEXTURE_LEVELS * (target == GL_TEXTURE_CUBE_MAP ? 6 : 1)), - mCompletenessCache(), - mBoundSurface(NULL) + mBoundSurface(nullptr), + mBoundStream(nullptr) { } -Texture::~Texture() +Error Texture::onDestroy(const Context *context) { if (mBoundSurface) { - mBoundSurface->releaseTexImage(EGL_BACK_BUFFER); - mBoundSurface = NULL; + ANGLE_TRY(mBoundSurface->releaseTexImage(context, EGL_BACK_BUFFER)); + mBoundSurface = nullptr; + } + if (mBoundStream) + { + mBoundStream->releaseTextures(); + mBoundStream = nullptr; } + + ANGLE_TRY(orphanImages(context)); + + if (mTexture) + { + ANGLE_TRY(mTexture->onDestroy(context)); + } + return NoError(); +} + +Texture::~Texture() +{ SafeDelete(mTexture); } void Texture::setLabel(const std::string &label) { mLabel = label; + mDirtyBits.set(DIRTY_BIT_LABEL); } const std::string &Texture::getLabel() const @@ -81,287 +586,303 @@ const std::string &Texture::getLabel() const GLenum Texture::getTarget() const { - return mTarget; + return mState.mTarget; } void Texture::setSwizzleRed(GLenum swizzleRed) { - mTextureState.swizzleRed = swizzleRed; + mState.mSwizzleState.swizzleRed = swizzleRed; + mDirtyBits.set(DIRTY_BIT_SWIZZLE_RED); } GLenum Texture::getSwizzleRed() const { - return mTextureState.swizzleRed; + return mState.mSwizzleState.swizzleRed; } void Texture::setSwizzleGreen(GLenum swizzleGreen) { - mTextureState.swizzleGreen = swizzleGreen; + mState.mSwizzleState.swizzleGreen = swizzleGreen; + mDirtyBits.set(DIRTY_BIT_SWIZZLE_GREEN); } GLenum Texture::getSwizzleGreen() const { - return mTextureState.swizzleGreen; + return mState.mSwizzleState.swizzleGreen; } void Texture::setSwizzleBlue(GLenum swizzleBlue) { - mTextureState.swizzleBlue = swizzleBlue; + mState.mSwizzleState.swizzleBlue = swizzleBlue; + mDirtyBits.set(DIRTY_BIT_SWIZZLE_BLUE); } GLenum Texture::getSwizzleBlue() const { - return mTextureState.swizzleBlue; + return mState.mSwizzleState.swizzleBlue; } void Texture::setSwizzleAlpha(GLenum swizzleAlpha) { - mTextureState.swizzleAlpha = swizzleAlpha; + mState.mSwizzleState.swizzleAlpha = swizzleAlpha; + mDirtyBits.set(DIRTY_BIT_SWIZZLE_ALPHA); } GLenum Texture::getSwizzleAlpha() const { - return mTextureState.swizzleAlpha; + return mState.mSwizzleState.swizzleAlpha; } void Texture::setMinFilter(GLenum minFilter) { - mTextureState.samplerState.minFilter = minFilter; + mState.mSamplerState.minFilter = minFilter; + mDirtyBits.set(DIRTY_BIT_MIN_FILTER); } GLenum Texture::getMinFilter() const { - return mTextureState.samplerState.minFilter; + return mState.mSamplerState.minFilter; } void Texture::setMagFilter(GLenum magFilter) { - mTextureState.samplerState.magFilter = magFilter; + mState.mSamplerState.magFilter = magFilter; + mDirtyBits.set(DIRTY_BIT_MAG_FILTER); } GLenum Texture::getMagFilter() const { - return mTextureState.samplerState.magFilter; + return mState.mSamplerState.magFilter; } void Texture::setWrapS(GLenum wrapS) { - mTextureState.samplerState.wrapS = wrapS; + mState.mSamplerState.wrapS = wrapS; + mDirtyBits.set(DIRTY_BIT_WRAP_S); } GLenum Texture::getWrapS() const { - return mTextureState.samplerState.wrapS; + return mState.mSamplerState.wrapS; } void Texture::setWrapT(GLenum wrapT) { - mTextureState.samplerState.wrapT = wrapT; + mState.mSamplerState.wrapT = wrapT; + mDirtyBits.set(DIRTY_BIT_WRAP_T); } GLenum Texture::getWrapT() const { - return mTextureState.samplerState.wrapT; + return mState.mSamplerState.wrapT; } void Texture::setWrapR(GLenum wrapR) { - mTextureState.samplerState.wrapR = wrapR; + mState.mSamplerState.wrapR = wrapR; + mDirtyBits.set(DIRTY_BIT_WRAP_R); } GLenum Texture::getWrapR() const { - return mTextureState.samplerState.wrapR; + return mState.mSamplerState.wrapR; } void Texture::setMaxAnisotropy(float maxAnisotropy) { - mTextureState.samplerState.maxAnisotropy = maxAnisotropy; + mState.mSamplerState.maxAnisotropy = maxAnisotropy; + mDirtyBits.set(DIRTY_BIT_MAX_ANISOTROPY); } float Texture::getMaxAnisotropy() const { - return mTextureState.samplerState.maxAnisotropy; + return mState.mSamplerState.maxAnisotropy; } void Texture::setMinLod(GLfloat minLod) { - mTextureState.samplerState.minLod = minLod; + mState.mSamplerState.minLod = minLod; + mDirtyBits.set(DIRTY_BIT_MIN_LOD); } GLfloat Texture::getMinLod() const { - return mTextureState.samplerState.minLod; + return mState.mSamplerState.minLod; } void Texture::setMaxLod(GLfloat maxLod) { - mTextureState.samplerState.maxLod = maxLod; + mState.mSamplerState.maxLod = maxLod; + mDirtyBits.set(DIRTY_BIT_MAX_LOD); } GLfloat Texture::getMaxLod() const { - return mTextureState.samplerState.maxLod; + return mState.mSamplerState.maxLod; } void Texture::setCompareMode(GLenum compareMode) { - mTextureState.samplerState.compareMode = compareMode; + mState.mSamplerState.compareMode = compareMode; + mDirtyBits.set(DIRTY_BIT_COMPARE_MODE); } GLenum Texture::getCompareMode() const { - return mTextureState.samplerState.compareMode; + return mState.mSamplerState.compareMode; } void Texture::setCompareFunc(GLenum compareFunc) { - mTextureState.samplerState.compareFunc = compareFunc; + mState.mSamplerState.compareFunc = compareFunc; + mDirtyBits.set(DIRTY_BIT_COMPARE_FUNC); } GLenum Texture::getCompareFunc() const { - return mTextureState.samplerState.compareFunc; + return mState.mSamplerState.compareFunc; +} + +void Texture::setSRGBDecode(GLenum sRGBDecode) +{ + mState.mSamplerState.sRGBDecode = sRGBDecode; + mDirtyBits.set(DIRTY_BIT_SRGB_DECODE); +} + +GLenum Texture::getSRGBDecode() const +{ + return mState.mSamplerState.sRGBDecode; } const SamplerState &Texture::getSamplerState() const { - return mTextureState.samplerState; + return mState.mSamplerState; } -void Texture::setBaseLevel(GLuint baseLevel) +Error Texture::setBaseLevel(const Context *context, GLuint baseLevel) { - mTextureState.baseLevel = baseLevel; + if (mState.setBaseLevel(baseLevel)) + { + ANGLE_TRY(mTexture->setBaseLevel(context, mState.getEffectiveBaseLevel())); + mDirtyBits.set(DIRTY_BIT_BASE_LEVEL); + invalidateCompletenessCache(); + } + + return NoError(); } GLuint Texture::getBaseLevel() const { - return mTextureState.baseLevel; + return mState.mBaseLevel; } void Texture::setMaxLevel(GLuint maxLevel) { - mTextureState.maxLevel = maxLevel; + if (mState.setMaxLevel(maxLevel)) + { + mDirtyBits.set(DIRTY_BIT_MAX_LEVEL); + invalidateCompletenessCache(); + } } GLuint Texture::getMaxLevel() const { - return mTextureState.maxLevel; + return mState.mMaxLevel; +} + +void Texture::setDepthStencilTextureMode(GLenum mode) +{ + if (mode != mState.mDepthStencilTextureMode) + { + // Changing the mode from the default state (GL_DEPTH_COMPONENT) is not implemented yet + UNIMPLEMENTED(); + } + + // TODO(geofflang): add dirty bits + mState.mDepthStencilTextureMode = mode; +} + +GLenum Texture::getDepthStencilTextureMode() const +{ + return mState.mDepthStencilTextureMode; } bool Texture::getImmutableFormat() const { - return mTextureState.immutableFormat; + return mState.mImmutableFormat; } GLuint Texture::getImmutableLevels() const { - return mTextureState.immutableLevels; + return mState.mImmutableLevels; } void Texture::setUsage(GLenum usage) { - mTextureState.usage = usage; - getImplementation()->setUsage(usage); + mState.mUsage = usage; + mDirtyBits.set(DIRTY_BIT_USAGE); } GLenum Texture::getUsage() const { - return mTextureState.usage; + return mState.mUsage; } const TextureState &Texture::getTextureState() const { - return mTextureState; + return mState; } size_t Texture::getWidth(GLenum target, size_t level) const { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - return getImageDesc(target, level).size.width; + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + return mState.getImageDesc(target, level).size.width; } size_t Texture::getHeight(GLenum target, size_t level) const { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - return getImageDesc(target, level).size.height; + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + return mState.getImageDesc(target, level).size.height; } size_t Texture::getDepth(GLenum target, size_t level) const { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - return getImageDesc(target, level).size.depth; + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + return mState.getImageDesc(target, level).size.depth; } -GLenum Texture::getInternalFormat(GLenum target, size_t level) const +const Format &Texture::getFormat(GLenum target, size_t level) const { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - return getImageDesc(target, level).internalFormat; + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + return mState.getImageDesc(target, level).format; } -bool Texture::isSamplerComplete(const SamplerState &samplerState, const Data &data) const +GLsizei Texture::getSamples(GLenum target, size_t level) const { - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), mTextureState.baseLevel); - const TextureCaps &textureCaps = data.textureCaps->get(baseImageDesc.internalFormat); - if (!mCompletenessCache.cacheValid || - mCompletenessCache.samplerState != samplerState || - mCompletenessCache.filterable != textureCaps.filterable || - mCompletenessCache.clientVersion != data.clientVersion || - mCompletenessCache.supportsNPOT != data.extensions->textureNPOT) - { - mCompletenessCache.cacheValid = true; - mCompletenessCache.samplerState = samplerState; - mCompletenessCache.filterable = textureCaps.filterable; - mCompletenessCache.clientVersion = data.clientVersion; - mCompletenessCache.supportsNPOT = data.extensions->textureNPOT; - mCompletenessCache.samplerComplete = computeSamplerCompleteness(samplerState, data); - } - return mCompletenessCache.samplerComplete; + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + return mState.getImageDesc(target, level).samples; } -bool Texture::isMipmapComplete() const +bool Texture::getFixedSampleLocations(GLenum target, size_t level) const { - return computeMipmapCompleteness(); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + return mState.getImageDesc(target, level).fixedSampleLocations; } -// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81. -bool Texture::isCubeComplete() const +GLuint Texture::getMipmapMaxLevel() const { - ASSERT(mTarget == GL_TEXTURE_CUBE_MAP); - - const ImageDesc &baseImageDesc = getImageDesc(FirstCubeMapTextureTarget, 0); - if (baseImageDesc.size.width == 0 || baseImageDesc.size.width != baseImageDesc.size.height) - { - return false; - } - - for (GLenum face = FirstCubeMapTextureTarget + 1; face <= LastCubeMapTextureTarget; face++) - { - const ImageDesc &faceImageDesc = getImageDesc(face, 0); - if (faceImageDesc.size.width != baseImageDesc.size.width || - faceImageDesc.size.height != baseImageDesc.size.height || - faceImageDesc.internalFormat != baseImageDesc.internalFormat) - { - return false; - } - } - - return true; + return mState.getMipmapMaxLevel(); } -size_t Texture::getMipCompleteLevels() const +bool Texture::isMipmapComplete() const { - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), 0); - if (mTarget == GL_TEXTURE_3D) - { - const int maxDim = std::max(std::max(baseImageDesc.size.width, baseImageDesc.size.height), - baseImageDesc.size.depth); - return log2(maxDim) + 1; - } - else - { - return log2(std::max(baseImageDesc.size.width, baseImageDesc.size.height)) + 1; - } + return mState.computeMipmapCompleteness(); } egl::Surface *Texture::getBoundSurface() const @@ -369,7 +890,19 @@ egl::Surface *Texture::getBoundSurface() const return mBoundSurface; } -Error Texture::setImage(Context *context, +egl::Stream *Texture::getBoundStream() const +{ + return mBoundStream; +} + +void Texture::signalDirty(InitState initState) const +{ + mDirtyChannel.signal(initState); + invalidateCompletenessCache(); +} + +Error Texture::setImage(const Context *context, + const PixelUnpackState &unpackState, GLenum target, size_t level, GLenum internalFormat, @@ -378,33 +911,25 @@ Error Texture::setImage(Context *context, GLenum type, const uint8_t *pixels) { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); // Release from previous calls to eglBindTexImage, to avoid calling the Impl after - releaseTexImageInternal(); - orphanImages(); + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); - // Hack: allow nullptr for testing - if (context != nullptr) - { - // Sync the unpack state - context->syncRendererState(context->getState().unpackStateBitMask()); - } + ANGLE_TRY(mTexture->setImage(context, target, level, internalFormat, size, format, type, + unpackState, pixels)); - const PixelUnpackState defaultUnpack; - const PixelUnpackState &unpack = context ? context->getState().getUnpackState() : defaultUnpack; - Error error = mTexture->setImage(target, level, internalFormat, size, format, type, unpack, pixels); - if (error.isError()) - { - return error; - } - - setImageDesc(target, level, ImageDesc(size, GetSizedInternalFormat(internalFormat, type))); + InitState initState = DetermineInitState(context, pixels); + mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat, type), initState)); + signalDirty(initState); - return Error(GL_NO_ERROR); + return NoError(); } -Error Texture::setSubImage(Context *context, +Error Texture::setSubImage(const Context *context, + const PixelUnpackState &unpackState, GLenum target, size_t level, const Box &area, @@ -412,16 +937,16 @@ Error Texture::setSubImage(Context *context, GLenum type, const uint8_t *pixels) { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - // Sync the unpack state - context->syncRendererState(context->getState().unpackStateBitMask()); + ANGLE_TRY(ensureSubImageInitialized(context, target, level, area)); - const PixelUnpackState &unpack = context->getState().getUnpackState(); - return mTexture->setSubImage(target, level, area, format, type, unpack, pixels); + return mTexture->setSubImage(context, target, level, area, format, type, unpackState, pixels); } -Error Texture::setCompressedImage(Context *context, +Error Texture::setCompressedImage(const Context *context, + const PixelUnpackState &unpackState, GLenum target, size_t level, GLenum internalFormat, @@ -429,28 +954,25 @@ Error Texture::setCompressedImage(Context *context, size_t imageSize, const uint8_t *pixels) { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); // Release from previous calls to eglBindTexImage, to avoid calling the Impl after - releaseTexImageInternal(); - orphanImages(); + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); - // Sync the unpack state - context->syncRendererState(context->getState().unpackStateBitMask()); - - const PixelUnpackState &unpack = context->getState().getUnpackState(); - Error error = mTexture->setCompressedImage(target, level, internalFormat, size, unpack, imageSize, pixels); - if (error.isError()) - { - return error; - } + ANGLE_TRY(mTexture->setCompressedImage(context, target, level, internalFormat, size, + unpackState, imageSize, pixels)); - setImageDesc(target, level, ImageDesc(size, GetSizedInternalFormat(internalFormat, GL_UNSIGNED_BYTE))); + InitState initState = DetermineInitState(context, pixels); + mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat), initState)); + signalDirty(initState); - return Error(GL_NO_ERROR); + return NoError(); } -Error Texture::setCompressedSubImage(Context *context, +Error Texture::setCompressedSubImage(const Context *context, + const PixelUnpackState &unpackState, GLenum target, size_t level, const Box &area, @@ -458,428 +980,505 @@ Error Texture::setCompressedSubImage(Context *context, size_t imageSize, const uint8_t *pixels) { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - // Sync the unpack state - context->syncRendererState(context->getState().unpackStateBitMask()); + ANGLE_TRY(ensureSubImageInitialized(context, target, level, area)); - const PixelUnpackState &unpack = context->getState().getUnpackState(); - return mTexture->setCompressedSubImage(target, level, area, format, unpack, imageSize, pixels); + return mTexture->setCompressedSubImage(context, target, level, area, format, unpackState, + imageSize, pixels); } -Error Texture::copyImage(GLenum target, size_t level, const Rectangle &sourceArea, GLenum internalFormat, - const Framebuffer *source) +Error Texture::copyImage(const Context *context, + GLenum target, + size_t level, + const Rectangle &sourceArea, + GLenum internalFormat, + Framebuffer *source) { - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); // Release from previous calls to eglBindTexImage, to avoid calling the Impl after - releaseTexImageInternal(); - orphanImages(); + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); - Error error = mTexture->copyImage(target, level, sourceArea, internalFormat, source); - if (error.isError()) - { - return error; - } + // Ensure source FBO is initialized. + ANGLE_TRY(source->ensureReadAttachmentInitialized(context, GL_COLOR_BUFFER_BIT)); - setImageDesc(target, level, ImageDesc(Extents(sourceArea.width, sourceArea.height, 1), - GetSizedInternalFormat(internalFormat, GL_UNSIGNED_BYTE))); + // Use the source FBO size as the init image area. + Box destBox(0, 0, 0, sourceArea.width, sourceArea.height, 1); + ANGLE_TRY(ensureSubImageInitialized(context, target, level, destBox)); - return Error(GL_NO_ERROR); -} + ANGLE_TRY(mTexture->copyImage(context, target, level, sourceArea, internalFormat, source)); -Error Texture::copySubImage(GLenum target, size_t level, const Offset &destOffset, const Rectangle &sourceArea, - const Framebuffer *source) -{ - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + const InternalFormat &internalFormatInfo = + GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE); - return mTexture->copySubImage(target, level, destOffset, sourceArea, source); + mState.setImageDesc(target, level, + ImageDesc(Extents(sourceArea.width, sourceArea.height, 1), + Format(internalFormatInfo), InitState::Initialized)); + + // We need to initialize this texture only if the source attachment is not initialized. + signalDirty(InitState::Initialized); + + return NoError(); } -Error Texture::setStorage(GLenum target, size_t levels, GLenum internalFormat, const Extents &size) +Error Texture::copySubImage(const Context *context, + GLenum target, + size_t level, + const Offset &destOffset, + const Rectangle &sourceArea, + Framebuffer *source) { - ASSERT(target == mTarget); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - // Release from previous calls to eglBindTexImage, to avoid calling the Impl after - releaseTexImageInternal(); - orphanImages(); + // Ensure source FBO is initialized. + ANGLE_TRY(source->ensureReadAttachmentInitialized(context, GL_COLOR_BUFFER_BIT)); - Error error = mTexture->setStorage(target, levels, internalFormat, size); - if (error.isError()) - { - return error; - } + Box destBox(destOffset.x, destOffset.y, destOffset.y, sourceArea.width, sourceArea.height, 1); + ANGLE_TRY(ensureSubImageInitialized(context, target, level, destBox)); - mTextureState.immutableFormat = true; - mTextureState.immutableLevels = static_cast<GLuint>(levels); - clearImageDescs(); - setImageDescChain(levels, size, internalFormat); - - return Error(GL_NO_ERROR); + return mTexture->copySubImage(context, target, level, destOffset, sourceArea, source); } -Error Texture::generateMipmaps() +Error Texture::copyTexture(const Context *context, + GLenum target, + size_t level, + GLenum internalFormat, + GLenum type, + size_t sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + Texture *source) { + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after - releaseTexImageInternal(); + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); - // EGL_KHR_gl_image states that images are only orphaned when generating mipmaps if the texture - // is not mip complete. - if (!isMipmapComplete()) - { - orphanImages(); - } + // Initialize source texture. + // Note: we don't have a way to notify which portions of the image changed currently. + ANGLE_TRY(source->ensureInitialized(context)); - Error error = mTexture->generateMipmaps(mTextureState); - if (error.isError()) - { - return error; - } + ANGLE_TRY(mTexture->copyTexture(context, target, level, internalFormat, type, sourceLevel, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha, + source)); - const ImageDesc &baseImageInfo = getImageDesc(getBaseImageTarget(), 0); - size_t mipLevels = log2(std::max(std::max(baseImageInfo.size.width, baseImageInfo.size.height), baseImageInfo.size.depth)) + 1; - setImageDescChain(mipLevels, baseImageInfo.size, baseImageInfo.internalFormat); + const auto &sourceDesc = source->mState.getImageDesc(source->getTarget(), 0); + const InternalFormat &internalFormatInfo = GetInternalFormatInfo(internalFormat, type); + mState.setImageDesc( + target, level, + ImageDesc(sourceDesc.size, Format(internalFormatInfo), InitState::Initialized)); - return Error(GL_NO_ERROR); + signalDirty(InitState::Initialized); + + return NoError(); } -void Texture::setImageDescChain(size_t levels, Extents baseSize, GLenum sizedInternalFormat) +Error Texture::copySubTexture(const Context *context, + GLenum target, + size_t level, + const Offset &destOffset, + size_t sourceLevel, + const Rectangle &sourceArea, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + Texture *source) { - for (int level = 0; level < static_cast<int>(levels); level++) - { - Extents levelSize( - std::max<int>(baseSize.width >> level, 1), std::max<int>(baseSize.height >> level, 1), - (mTarget == GL_TEXTURE_2D_ARRAY) ? baseSize.depth - : std::max<int>(baseSize.depth >> level, 1)); - ImageDesc levelInfo(levelSize, sizedInternalFormat); + ASSERT(target == mState.mTarget || + (mState.mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - if (mTarget == GL_TEXTURE_CUBE_MAP) - { - for (GLenum face = FirstCubeMapTextureTarget; face <= LastCubeMapTextureTarget; face++) - { - setImageDesc(face, level, levelInfo); - } - } - else - { - setImageDesc(mTarget, level, levelInfo); - } - } -} + // Ensure source is initialized. + ANGLE_TRY(source->ensureInitialized(context)); -Texture::ImageDesc::ImageDesc() - : ImageDesc(Extents(0, 0, 0), GL_NONE) -{ -} + Box destBox(destOffset.x, destOffset.y, destOffset.y, sourceArea.width, sourceArea.height, 1); + ANGLE_TRY(ensureSubImageInitialized(context, target, level, destBox)); -Texture::ImageDesc::ImageDesc(const Extents &size, GLenum internalFormat) - : size(size), - internalFormat(internalFormat) -{ + return mTexture->copySubTexture(context, target, level, destOffset, sourceLevel, sourceArea, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha, + source); } -const Texture::ImageDesc &Texture::getImageDesc(GLenum target, size_t level) const +Error Texture::copyCompressedTexture(const Context *context, const Texture *source) { - size_t descIndex = GetImageDescIndex(target, level); - ASSERT(descIndex < mImageDescs.size()); - return mImageDescs[descIndex]; + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); + + ANGLE_TRY(mTexture->copyCompressedTexture(context, source)); + + ASSERT(source->getTarget() != GL_TEXTURE_CUBE_MAP && getTarget() != GL_TEXTURE_CUBE_MAP); + const auto &sourceDesc = source->mState.getImageDesc(source->getTarget(), 0); + mState.setImageDesc(getTarget(), 0, sourceDesc); + + return NoError(); } -void Texture::setImageDesc(GLenum target, size_t level, const ImageDesc &desc) +Error Texture::setStorage(const Context *context, + GLenum target, + GLsizei levels, + GLenum internalFormat, + const Extents &size) { - size_t descIndex = GetImageDescIndex(target, level); - ASSERT(descIndex < mImageDescs.size()); - mImageDescs[descIndex] = desc; - mCompletenessCache.cacheValid = false; + ASSERT(target == mState.mTarget); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); + + ANGLE_TRY(mTexture->setStorage(context, target, levels, internalFormat, size)); + + mState.mImmutableFormat = true; + mState.mImmutableLevels = static_cast<GLuint>(levels); + mState.clearImageDescs(); + mState.setImageDescChain(0, static_cast<GLuint>(levels - 1), size, Format(internalFormat), + InitState::MayNeedInit); + + // Changing the texture to immutable can trigger a change in the base and max levels: + // GLES 3.0.4 section 3.8.10 pg 158: + // "For immutable-format textures, levelbase is clamped to the range[0;levels],levelmax is then + // clamped to the range[levelbase;levels]. + mDirtyBits.set(DIRTY_BIT_BASE_LEVEL); + mDirtyBits.set(DIRTY_BIT_MAX_LEVEL); + + signalDirty(InitState::MayNeedInit); + + return NoError(); } -void Texture::clearImageDesc(GLenum target, size_t level) +Error Texture::setStorageMultisample(const Context *context, + GLenum target, + GLsizei samples, + GLint internalFormat, + const Extents &size, + bool fixedSampleLocations) { - setImageDesc(target, level, ImageDesc()); + ASSERT(target == mState.mTarget); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); + + ANGLE_TRY(mTexture->setStorageMultisample(context, target, samples, internalFormat, size, + fixedSampleLocations)); + + mState.mImmutableFormat = true; + mState.mImmutableLevels = static_cast<GLuint>(1); + mState.clearImageDescs(); + mState.setImageDescChainMultisample(size, Format(internalFormat), samples, fixedSampleLocations, + InitState::MayNeedInit); + + signalDirty(InitState::MayNeedInit); + + return NoError(); } -void Texture::clearImageDescs() +Error Texture::generateMipmap(const Context *context) { - for (size_t descIndex = 0; descIndex < mImageDescs.size(); descIndex++) + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + // EGL_KHR_gl_image states that images are only orphaned when generating mipmaps if the texture + // is not mip complete. + if (!isMipmapComplete()) { - mImageDescs[descIndex] = ImageDesc(); + ANGLE_TRY(orphanImages(context)); } - mCompletenessCache.cacheValid = false; + + const GLuint baseLevel = mState.getEffectiveBaseLevel(); + const GLuint maxLevel = mState.getMipmapMaxLevel(); + + if (maxLevel > baseLevel) + { + syncState(); + const ImageDesc &baseImageInfo = + mState.getImageDesc(mState.getBaseImageTarget(), baseLevel); + + // Clear the base image immediately if necessary. + if (context->isRobustResourceInitEnabled() && + baseImageInfo.initState == InitState::MayNeedInit) + { + ANGLE_TRY(initializeContents( + context, GetImageIndexFromDescIndex(mState.getBaseImageTarget(), baseLevel))); + } + + ANGLE_TRY(mTexture->generateMipmap(context)); + + mState.setImageDescChain(baseLevel, maxLevel, baseImageInfo.size, baseImageInfo.format, + InitState::Initialized); + } + + signalDirty(InitState::Initialized); + + return NoError(); } -void Texture::bindTexImageFromSurface(egl::Surface *surface) +Error Texture::bindTexImageFromSurface(const Context *context, egl::Surface *surface) { ASSERT(surface); if (mBoundSurface) { - releaseTexImageFromSurface(); + ANGLE_TRY(releaseTexImageFromSurface(context)); } - mTexture->bindTexImage(surface); + ANGLE_TRY(mTexture->bindTexImage(context, surface)); mBoundSurface = surface; // Set the image info to the size and format of the surface - ASSERT(mTarget == GL_TEXTURE_2D); + ASSERT(mState.mTarget == GL_TEXTURE_2D || mState.mTarget == GL_TEXTURE_RECTANGLE_ANGLE); Extents size(surface->getWidth(), surface->getHeight(), 1); - ImageDesc desc(size, surface->getConfig()->renderTargetFormat); - setImageDesc(mTarget, 0, desc); + ImageDesc desc(size, Format(surface->getConfig()->renderTargetFormat), InitState::Initialized); + mState.setImageDesc(mState.mTarget, 0, desc); + signalDirty(InitState::Initialized); + return NoError(); } -void Texture::releaseTexImageFromSurface() +Error Texture::releaseTexImageFromSurface(const Context *context) { ASSERT(mBoundSurface); mBoundSurface = nullptr; - mTexture->releaseTexImage(); + ANGLE_TRY(mTexture->releaseTexImage(context)); // Erase the image info for level 0 - ASSERT(mTarget == GL_TEXTURE_2D); - clearImageDesc(mTarget, 0); + ASSERT(mState.mTarget == GL_TEXTURE_2D || mState.mTarget == GL_TEXTURE_RECTANGLE_ANGLE); + mState.clearImageDesc(mState.mTarget, 0); + signalDirty(InitState::Initialized); + return NoError(); } -void Texture::releaseTexImageInternal() +void Texture::bindStream(egl::Stream *stream) +{ + ASSERT(stream); + + // It should not be possible to bind a texture already bound to another stream + ASSERT(mBoundStream == nullptr); + + mBoundStream = stream; + + ASSERT(mState.mTarget == GL_TEXTURE_EXTERNAL_OES); +} + +void Texture::releaseStream() +{ + ASSERT(mBoundStream); + mBoundStream = nullptr; +} + +Error Texture::acquireImageFromStream(const Context *context, + const egl::Stream::GLTextureDescription &desc) +{ + ASSERT(mBoundStream != nullptr); + ANGLE_TRY(mTexture->setImageExternal(context, mState.mTarget, mBoundStream, desc)); + + Extents size(desc.width, desc.height, 1); + mState.setImageDesc(mState.mTarget, 0, + ImageDesc(size, Format(desc.internalFormat), InitState::Initialized)); + signalDirty(InitState::Initialized); + return NoError(); +} + +Error Texture::releaseImageFromStream(const Context *context) +{ + ASSERT(mBoundStream != nullptr); + ANGLE_TRY(mTexture->setImageExternal(context, mState.mTarget, nullptr, + egl::Stream::GLTextureDescription())); + + // Set to incomplete + mState.clearImageDesc(mState.mTarget, 0); + signalDirty(InitState::Initialized); + return NoError(); +} + +Error Texture::releaseTexImageInternal(const Context *context) { if (mBoundSurface) { // Notify the surface - mBoundSurface->releaseTexImageFromTexture(); + mBoundSurface->releaseTexImageFromTexture(context); // Then, call the same method as from the surface - releaseTexImageFromSurface(); + ANGLE_TRY(releaseTexImageFromSurface(context)); } + return NoError(); } -Error Texture::setEGLImageTarget(GLenum target, egl::Image *imageTarget) +Error Texture::setEGLImageTarget(const Context *context, GLenum target, egl::Image *imageTarget) { - ASSERT(target == mTarget); - ASSERT(target == GL_TEXTURE_2D); + ASSERT(target == mState.mTarget); + ASSERT(target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES); // Release from previous calls to eglBindTexImage, to avoid calling the Impl after - releaseTexImageInternal(); - orphanImages(); + ANGLE_TRY(releaseTexImageInternal(context)); + ANGLE_TRY(orphanImages(context)); - Error error = mTexture->setEGLImageTarget(target, imageTarget); - if (error.isError()) - { - return error; - } + ANGLE_TRY(mTexture->setEGLImageTarget(context, target, imageTarget)); - setTargetImage(imageTarget); + setTargetImage(context, imageTarget); Extents size(static_cast<int>(imageTarget->getWidth()), static_cast<int>(imageTarget->getHeight()), 1); - GLenum internalFormat = imageTarget->getInternalFormat(); - GLenum type = GetInternalFormatInfo(internalFormat).type; - clearImageDescs(); - setImageDesc(target, 0, ImageDesc(size, GetSizedInternalFormat(internalFormat, type))); + auto initState = imageTarget->sourceInitState(); + + mState.clearImageDescs(); + mState.setImageDesc(target, 0, ImageDesc(size, imageTarget->getFormat(), initState)); + signalDirty(initState); - return Error(GL_NO_ERROR); + return NoError(); } -GLenum Texture::getBaseImageTarget() const +Extents Texture::getAttachmentSize(const ImageIndex &imageIndex) const { - return mTarget == GL_TEXTURE_CUBE_MAP ? FirstCubeMapTextureTarget : mTarget; + return mState.getImageDesc(imageIndex).size; } -bool Texture::computeSamplerCompleteness(const SamplerState &samplerState, const Data &data) const +const Format &Texture::getAttachmentFormat(GLenum /*binding*/, const ImageIndex &imageIndex) const { - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), mTextureState.baseLevel); - if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 || baseImageDesc.size.depth == 0) - { - return false; - } - - if (mTarget == GL_TEXTURE_CUBE_MAP && baseImageDesc.size.width != baseImageDesc.size.height) - { - return false; - } - - const TextureCaps &textureCaps = data.textureCaps->get(baseImageDesc.internalFormat); - if (!textureCaps.filterable && !IsPointSampled(samplerState)) - { - return false; - } - - bool npotSupport = data.extensions->textureNPOT || data.clientVersion >= 3; - if (!npotSupport) - { - if ((samplerState.wrapS != GL_CLAMP_TO_EDGE && !gl::isPow2(baseImageDesc.size.width)) || - (samplerState.wrapT != GL_CLAMP_TO_EDGE && !gl::isPow2(baseImageDesc.size.height))) - { - return false; - } - } - - if (IsMipmapFiltered(samplerState)) - { - if (!npotSupport) - { - if (!gl::isPow2(baseImageDesc.size.width) || !gl::isPow2(baseImageDesc.size.height)) - { - return false; - } - } - - if (!computeMipmapCompleteness()) - { - return false; - } - } - else - { - if (mTarget == GL_TEXTURE_CUBE_MAP && !isCubeComplete()) - { - return false; - } - } + return mState.getImageDesc(imageIndex).format; +} - // OpenGLES 3.0.2 spec section 3.8.13 states that a texture is not mipmap complete if: - // The internalformat specified for the texture arrays is a sized internal depth or - // depth and stencil format (see table 3.13), the value of TEXTURE_COMPARE_- - // MODE is NONE, and either the magnification filter is not NEAREST or the mini- - // fication filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST. - const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(baseImageDesc.internalFormat); - if (formatInfo.depthBits > 0 && data.clientVersion > 2) - { - if (samplerState.compareMode == GL_NONE) - { - if ((samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST) || - samplerState.magFilter != GL_NEAREST) - { - return false; - } - } - } +GLsizei Texture::getAttachmentSamples(const ImageIndex &imageIndex) const +{ + return getSamples(imageIndex.type, 0); +} - return true; +void Texture::onAttach(const Context *context) +{ + addRef(); } -bool Texture::computeMipmapCompleteness() const +void Texture::onDetach(const Context *context) { - size_t expectedMipLevels = getMipCompleteLevels(); + release(context); +} - size_t maxLevel = std::min<size_t>(expectedMipLevels, mTextureState.maxLevel + 1); +GLuint Texture::getId() const +{ + return id(); +} - for (size_t level = mTextureState.baseLevel; level < maxLevel; level++) - { - if (mTarget == GL_TEXTURE_CUBE_MAP) - { - for (GLenum face = FirstCubeMapTextureTarget; face <= LastCubeMapTextureTarget; face++) - { - if (!computeLevelCompleteness(face, level)) - { - return false; - } - } - } - else - { - if (!computeLevelCompleteness(mTarget, level)) - { - return false; - } - } - } +void Texture::syncState() +{ + mTexture->syncState(mDirtyBits); + mDirtyBits.reset(); +} - return true; +rx::FramebufferAttachmentObjectImpl *Texture::getAttachmentImpl() const +{ + return mTexture; } -bool Texture::computeLevelCompleteness(GLenum target, size_t level) const +bool Texture::isSamplerComplete(const Context *context, const Sampler *optionalSampler) { - ASSERT(level < IMPLEMENTATION_MAX_TEXTURE_LEVELS); + const auto &samplerState = + optionalSampler ? optionalSampler->getSamplerState() : mState.mSamplerState; + const auto &contextState = context->getContextState(); - if (mTextureState.immutableFormat) + if (contextState.getContextID() != mCompletenessCache.context || + mCompletenessCache.samplerState != samplerState) { - return true; + mCompletenessCache.context = context->getContextState().getContextID(); + mCompletenessCache.samplerState = samplerState; + mCompletenessCache.samplerComplete = + mState.computeSamplerCompleteness(samplerState, contextState); } - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), mTextureState.baseLevel); - if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 || baseImageDesc.size.depth == 0) - { - return false; - } + return mCompletenessCache.samplerComplete; +} - const ImageDesc &levelImageDesc = getImageDesc(target, level); - if (levelImageDesc.size.width == 0 || levelImageDesc.size.height == 0 || - levelImageDesc.size.depth == 0) - { - return false; - } +Texture::SamplerCompletenessCache::SamplerCompletenessCache() + : context(0), samplerState(), samplerComplete(false) +{ +} - if (levelImageDesc.internalFormat != baseImageDesc.internalFormat) - { - return false; - } +void Texture::invalidateCompletenessCache() const +{ + mCompletenessCache.context = 0; +} - ASSERT(level >= mTextureState.baseLevel); - const size_t relativeLevel = level - mTextureState.baseLevel; - if (levelImageDesc.size.width != std::max(1, baseImageDesc.size.width >> relativeLevel)) +Error Texture::ensureInitialized(const Context *context) +{ + if (!context->isRobustResourceInitEnabled() || mState.mInitState == InitState::Initialized) { - return false; + return NoError(); } - if (levelImageDesc.size.height != std::max(1, baseImageDesc.size.height >> relativeLevel)) - { - return false; - } + bool anyDirty = false; - if (mTarget == GL_TEXTURE_3D) + for (size_t descIndex = 0; descIndex < mState.mImageDescs.size(); ++descIndex) { - if (levelImageDesc.size.depth != std::max(1, baseImageDesc.size.depth >> relativeLevel)) + auto &imageDesc = mState.mImageDescs[descIndex]; + if (imageDesc.initState == InitState::MayNeedInit) { - return false; + ASSERT(mState.mInitState == InitState::MayNeedInit); + const auto &imageIndex = GetImageIndexFromDescIndex(mState.mTarget, descIndex); + ANGLE_TRY(initializeContents(context, imageIndex)); + imageDesc.initState = InitState::Initialized; + anyDirty = true; } } - else if (mTarget == GL_TEXTURE_2D_ARRAY) + if (anyDirty) { - if (levelImageDesc.size.depth != baseImageDesc.size.depth) - { - return false; - } + signalDirty(InitState::Initialized); } + mState.mInitState = InitState::Initialized; - return true; + return NoError(); } -Texture::SamplerCompletenessCache::SamplerCompletenessCache() - : cacheValid(false), - samplerState(), - filterable(false), - clientVersion(0), - supportsNPOT(false), - samplerComplete(false) +InitState Texture::initState(const ImageIndex &imageIndex) const { + return mState.getImageDesc(imageIndex).initState; } -Extents Texture::getAttachmentSize(const gl::FramebufferAttachment::Target &target) const +InitState Texture::initState() const { - return getImageDesc(target.textureIndex().type, target.textureIndex().mipIndex).size; + return mState.mInitState; } -GLenum Texture::getAttachmentInternalFormat(const gl::FramebufferAttachment::Target &target) const +void Texture::setInitState(const ImageIndex &imageIndex, InitState initState) { - return getInternalFormat(target.textureIndex().type, target.textureIndex().mipIndex); + ImageDesc newDesc = mState.getImageDesc(imageIndex); + newDesc.initState = initState; + mState.setImageDesc(imageIndex.type, imageIndex.mipIndex, newDesc); } -GLsizei Texture::getAttachmentSamples(const gl::FramebufferAttachment::Target &/*target*/) const +Error Texture::ensureSubImageInitialized(const Context *context, + GLenum target, + size_t level, + const gl::Box &area) { - // Multisample textures not currently supported - return 0; -} + if (!context->isRobustResourceInitEnabled() || mState.mInitState == InitState::Initialized) + { + return NoError(); + } -void Texture::onAttach() -{ - addRef(); -} + // Pre-initialize the texture contents if necessary. + // TODO(jmadill): Check if area overlaps the entire texture. + const auto &imageIndex = GetImageIndexFromDescIndex(target, level); + const auto &desc = mState.getImageDesc(imageIndex); + if (desc.initState == InitState::MayNeedInit) + { + ASSERT(mState.mInitState == InitState::MayNeedInit); + bool coversWholeImage = area.x == 0 && area.y == 0 && area.z == 0 && + area.width == desc.size.width && area.height == desc.size.height && + area.depth == desc.size.depth; + if (!coversWholeImage) + { + ANGLE_TRY(initializeContents(context, imageIndex)); + } + setInitState(imageIndex, InitState::Initialized); + } -void Texture::onDetach() -{ - release(); + return NoError(); } -GLuint Texture::getId() const -{ - return id(); -} -} +} // namespace gl |