From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- gfx/angle/checkout/src/libANGLE/Texture.cpp | 2494 +++++++++++++++++++++++++++ 1 file changed, 2494 insertions(+) create mode 100644 gfx/angle/checkout/src/libANGLE/Texture.cpp (limited to 'gfx/angle/checkout/src/libANGLE/Texture.cpp') diff --git a/gfx/angle/checkout/src/libANGLE/Texture.cpp b/gfx/angle/checkout/src/libANGLE/Texture.cpp new file mode 100644 index 0000000000..89930d1c29 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/Texture.cpp @@ -0,0 +1,2494 @@ +// +// 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.cpp: Implements the gl::Texture class. [OpenGL ES 2.0.24] section 3.7 page 63. + +#include "libANGLE/Texture.h" + +#include "common/mathutil.h" +#include "common/utilities.h" +#include "libANGLE/Config.h" +#include "libANGLE/Context.h" +#include "libANGLE/Image.h" +#include "libANGLE/State.h" +#include "libANGLE/Surface.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/GLImplFactory.h" +#include "libANGLE/renderer/TextureImpl.h" + +namespace gl +{ + +namespace +{ +constexpr angle::SubjectIndex kBufferSubjectIndex = 2; +static_assert(kBufferSubjectIndex != rx::kTextureImageImplObserverMessageIndex, "Index collision"); +static_assert(kBufferSubjectIndex != rx::kTextureImageSiblingMessageIndex, "Index collision"); + +bool IsPointSampled(const SamplerState &samplerState) +{ + return (samplerState.getMagFilter() == GL_NEAREST && + (samplerState.getMinFilter() == GL_NEAREST || + samplerState.getMinFilter() == GL_NEAREST_MIPMAP_NEAREST)); +} + +size_t GetImageDescIndex(TextureTarget target, size_t level) +{ + return IsCubeMapFaceTarget(target) ? (level * 6 + CubeMapTextureTargetToFaceIndex(target)) + : level; +} + +InitState DetermineInitState(const Context *context, Buffer *unpackBuffer, const uint8_t *pixels) +{ + // Can happen in tests. + if (!context || !context->isRobustResourceInitEnabled()) + { + return InitState::Initialized; + } + + return (!pixels && !unpackBuffer) ? InitState::MayNeedInit : InitState::Initialized; +} +} // namespace + +GLenum ConvertToNearestFilterMode(GLenum filterMode) +{ + switch (filterMode) + { + case GL_LINEAR: + return GL_NEAREST; + case GL_LINEAR_MIPMAP_NEAREST: + return GL_NEAREST_MIPMAP_NEAREST; + case GL_LINEAR_MIPMAP_LINEAR: + return GL_NEAREST_MIPMAP_LINEAR; + default: + return filterMode; + } +} + +GLenum ConvertToNearestMipFilterMode(GLenum filterMode) +{ + switch (filterMode) + { + case GL_LINEAR_MIPMAP_LINEAR: + return GL_LINEAR_MIPMAP_NEAREST; + case GL_NEAREST_MIPMAP_LINEAR: + return GL_NEAREST_MIPMAP_NEAREST; + default: + return filterMode; + } +} + +bool IsMipmapSupported(const TextureType &type) +{ + if (type == TextureType::_2DMultisample || type == TextureType::Buffer) + { + return false; + } + return true; +} + +SwizzleState::SwizzleState() + : swizzleRed(GL_RED), swizzleGreen(GL_GREEN), swizzleBlue(GL_BLUE), swizzleAlpha(GL_ALPHA) +{} + +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(TextureType type) + : mType(type), + mSamplerState(SamplerState::CreateDefaultForTarget(type)), + mSrgbOverride(SrgbOverride::Default), + mBaseLevel(0), + mMaxLevel(kInitialMaxLevel), + mDepthStencilTextureMode(GL_DEPTH_COMPONENT), + mHasBeenBoundAsImage(false), + mIs3DAndHasBeenBoundAs2DImage(false), + mHasBeenBoundAsAttachment(false), + mImmutableFormat(false), + mImmutableLevels(0), + mUsage(GL_NONE), + mHasProtectedContent(false), + mImageDescs((IMPLEMENTATION_MAX_TEXTURE_LEVELS + 1) * (type == TextureType::CubeMap ? 6 : 1)), + mCropRect(0, 0, 0, 0), + mGenerateMipmapHint(GL_FALSE), + mInitState(InitState::Initialized), + mCachedSamplerFormat(SamplerFormat::InvalidEnum), + mCachedSamplerCompareMode(GL_NONE), + mCachedSamplerFormatValid(false) +{} + +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(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 (mType == TextureType::_3D) + { + const int maxDim = std::max(std::max(baseImageDesc.size.width, baseImageDesc.size.height), + baseImageDesc.size.depth); + expectedMipLevels = static_cast(log2(maxDim)); + } + else + { + expectedMipLevels = static_cast( + log2(std::max(baseImageDesc.size.width, baseImageDesc.size.height))); + } + + return std::min(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(mType == TextureType::CubeMap); + + angle::EnumIterator face = kCubeMapTextureTargetMin; + const ImageDesc &baseImageDesc = getImageDesc(*face, getEffectiveBaseLevel()); + if (baseImageDesc.size.width == 0 || baseImageDesc.size.width != baseImageDesc.size.height) + { + return false; + } + + ++face; + + for (; face != kAfterCubeMapTextureTargetMax; ++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; +} + +const ImageDesc &TextureState::getBaseLevelDesc() const +{ + ASSERT(mType != TextureType::CubeMap || isCubeComplete()); + return getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel()); +} + +const ImageDesc &TextureState::getLevelZeroDesc() const +{ + ASSERT(mType != TextureType::CubeMap || isCubeComplete()); + return getImageDesc(getBaseImageTarget(), 0); +} + +void TextureState::setCrop(const Rectangle &rect) +{ + mCropRect = rect; +} + +const Rectangle &TextureState::getCrop() const +{ + return mCropRect; +} + +void TextureState::setGenerateMipmapHint(GLenum hint) +{ + mGenerateMipmapHint = hint; +} + +GLenum TextureState::getGenerateMipmapHint() const +{ + return mGenerateMipmapHint; +} + +SamplerFormat TextureState::computeRequiredSamplerFormat(const SamplerState &samplerState) const +{ + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel()); + if ((baseImageDesc.format.info->format == GL_DEPTH_COMPONENT || + baseImageDesc.format.info->format == GL_DEPTH_STENCIL) && + samplerState.getCompareMode() != GL_NONE) + { + return SamplerFormat::Shadow; + } + else + { + switch (baseImageDesc.format.info->componentType) + { + case GL_UNSIGNED_NORMALIZED: + case GL_SIGNED_NORMALIZED: + case GL_FLOAT: + return SamplerFormat::Float; + case GL_INT: + return SamplerFormat::Signed; + case GL_UNSIGNED_INT: + return SamplerFormat::Unsigned; + default: + return SamplerFormat::InvalidEnum; + } + } +} + +bool TextureState::computeSamplerCompleteness(const SamplerState &samplerState, + const State &state) const +{ + // Buffer textures cannot be incomplete. + if (mType == TextureType::Buffer) + { + return true; + } + + // Check for all non-format-based completeness rules + if (!computeSamplerCompletenessForCopyImage(samplerState, state)) + { + return false; + } + + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel()); + + // 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 (!IsMultisampled(mType) && + !baseImageDesc.format.info->filterSupport(state.getClientVersion(), + state.getExtensions()) && + !IsPointSampled(samplerState)) + { + 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 (!IsMultisampled(mType) && baseImageDesc.format.info->depthBits > 0 && + state.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.getCompareMode() == GL_NONE && baseImageDesc.format.info->sized) + { + if ((samplerState.getMinFilter() != GL_NEAREST && + samplerState.getMinFilter() != GL_NEAREST_MIPMAP_NEAREST) || + samplerState.getMagFilter() != GL_NEAREST) + { + return false; + } + } + } + + // OpenGLES 3.1 spec section 8.16 states that a texture is not mipmap complete if: + // The internalformat specified for the texture is DEPTH_STENCIL format, the value of + // DEPTH_STENCIL_TEXTURE_MODE is STENCIL_INDEX, and either the magnification filter is + // not NEAREST or the minification filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST. + // However, the ES 3.1 spec differs from the statement above, because it is incorrect. + // See the issue at https://github.com/KhronosGroup/OpenGL-API/issues/33. + // 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 (!IsMultisampled(mType) && baseImageDesc.format.info->depthBits > 0 && + mDepthStencilTextureMode == GL_STENCIL_INDEX) + { + if ((samplerState.getMinFilter() != GL_NEAREST && + samplerState.getMinFilter() != GL_NEAREST_MIPMAP_NEAREST) || + samplerState.getMagFilter() != GL_NEAREST) + { + return false; + } + } + + return true; +} + +// CopyImageSubData has more lax rules for texture completeness: format-based completeness rules are +// ignored, so a texture can still be considered complete even if it violates format-specific +// conditions +bool TextureState::computeSamplerCompletenessForCopyImage(const SamplerState &samplerState, + const State &state) const +{ + // Buffer textures cannot be incomplete. + if (mType == TextureType::Buffer) + { + return true; + } + + if (!mImmutableFormat && 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 (mType == TextureType::CubeMap && baseImageDesc.size.width != baseImageDesc.size.height) + { + return false; + } + + bool npotSupport = state.getExtensions().textureNpotOES || state.getClientMajorVersion() >= 3; + if (!npotSupport) + { + if ((samplerState.getWrapS() != GL_CLAMP_TO_EDGE && + samplerState.getWrapS() != GL_CLAMP_TO_BORDER && !isPow2(baseImageDesc.size.width)) || + (samplerState.getWrapT() != GL_CLAMP_TO_EDGE && + samplerState.getWrapT() != GL_CLAMP_TO_BORDER && !isPow2(baseImageDesc.size.height))) + { + return false; + } + } + + if (IsMipmapSupported(mType) && IsMipmapFiltered(samplerState.getMinFilter())) + { + if (!npotSupport) + { + if (!isPow2(baseImageDesc.size.width) || !isPow2(baseImageDesc.size.height)) + { + return false; + } + } + + if (!computeMipmapCompleteness()) + { + return false; + } + } + else + { + if (mType == TextureType::CubeMap && !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 and EXT_EGL_image_external_wrap_modes is not enabled, 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 (mType == TextureType::External) + { + if (!state.getExtensions().EGLImageExternalWrapModesEXT) + { + if (samplerState.getWrapS() != GL_CLAMP_TO_EDGE || + samplerState.getWrapT() != GL_CLAMP_TO_EDGE) + { + return false; + } + } + + if (samplerState.getMinFilter() != GL_LINEAR && samplerState.getMinFilter() != GL_NEAREST) + { + return false; + } + } + + return true; +} + +bool TextureState::computeMipmapCompleteness() const +{ + const GLuint maxLevel = getMipmapMaxLevel(); + + for (GLuint level = getEffectiveBaseLevel(); level <= maxLevel; level++) + { + if (mType == TextureType::CubeMap) + { + for (TextureTarget face : AllCubeFaceTextureTargets()) + { + if (!computeLevelCompleteness(face, level)) + { + return false; + } + } + } + else + { + if (!computeLevelCompleteness(NonCubeTextureTypeToTarget(mType), level)) + { + return false; + } + } + } + + return true; +} + +bool TextureState::computeLevelCompleteness(TextureTarget target, size_t level) const +{ + ASSERT(level < IMPLEMENTATION_MAX_TEXTURE_LEVELS); + + if (mImmutableFormat) + { + return true; + } + + 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 (mType == TextureType::_3D) + { + if (levelImageDesc.size.depth != std::max(1, baseImageDesc.size.depth >> relativeLevel)) + { + return false; + } + } + else if (IsArrayTextureType(mType)) + { + if (levelImageDesc.size.depth != baseImageDesc.size.depth) + { + return false; + } + } + + return true; +} + +TextureTarget TextureState::getBaseImageTarget() const +{ + return mType == TextureType::CubeMap ? kCubeMapTextureTargetMin + : NonCubeTextureTypeToTarget(mType); +} + +GLuint TextureState::getEnabledLevelCount() const +{ + GLuint levelCount = 0; + const GLuint baseLevel = getEffectiveBaseLevel(); + const GLuint maxLevel = std::min(getEffectiveMaxLevel(), getMipmapMaxLevel()); + + // The mip chain will have either one or more sequential levels, or max levels, + // but not a sparse one. + Optional expectedSize; + for (size_t enabledLevel = baseLevel; enabledLevel <= maxLevel; ++enabledLevel, ++levelCount) + { + // Note: for cube textures, we only check the first face. + TextureTarget target = TextureTypeToTarget(mType, 0); + size_t descIndex = GetImageDescIndex(target, enabledLevel); + const Extents &levelSize = mImageDescs[descIndex].size; + + if (levelSize.empty()) + { + break; + } + if (expectedSize.valid()) + { + Extents newSize = expectedSize.value(); + newSize.width = std::max(1, newSize.width >> 1); + newSize.height = std::max(1, newSize.height >> 1); + + if (!IsArrayTextureType(mType)) + { + newSize.depth = std::max(1, newSize.depth >> 1); + } + + if (newSize != levelSize) + { + break; + } + } + expectedSize = levelSize; + } + + return levelCount; +} + +ImageDesc::ImageDesc() + : ImageDesc(Extents(0, 0, 0), Format::Invalid(), 0, GL_TRUE, InitState::Initialized) +{} + +ImageDesc::ImageDesc(const Extents &size, const Format &format, const InitState initState) + : size(size), format(format), samples(0), fixedSampleLocations(GL_TRUE), initState(initState) +{} + +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) +{} + +GLint ImageDesc::getMemorySize() const +{ + // Assume allocated size is around width * height * depth * samples * pixelBytes + angle::CheckedNumeric levelSize = 1; + levelSize *= format.info->pixelBytes; + levelSize *= size.width; + levelSize *= size.height; + levelSize *= size.depth; + levelSize *= std::max(samples, 1); + return levelSize.ValueOrDefault(std::numeric_limits::max()); +} + +const ImageDesc &TextureState::getImageDesc(TextureTarget target, size_t level) const +{ + size_t descIndex = GetImageDescIndex(target, level); + ASSERT(descIndex < mImageDescs.size()); + return mImageDescs[descIndex]; +} + +void TextureState::setImageDesc(TextureTarget 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; + } + else + { + // Scan for any uninitialized images. If there are none, set the init state of the entire + // texture to initialized. The cost of the scan is only paid after doing image + // initialization which is already very expensive. + bool allImagesInitialized = true; + + for (const ImageDesc &initDesc : mImageDescs) + { + if (initDesc.initState == InitState::MayNeedInit) + { + allImagesInitialized = false; + break; + } + } + + if (allImagesInitialized) + { + mInitState = InitState::Initialized; + } + } +} + +// Note that an ImageIndex that represents an entire level of a cube map corresponds to 6 +// ImageDescs, so if the cube map is cube complete, we return the ImageDesc of the first cube +// face, and we don't allow using this function when the cube map is not cube complete. +const ImageDesc &TextureState::getImageDesc(const ImageIndex &imageIndex) const +{ + if (imageIndex.isEntireLevelCubeMap()) + { + ASSERT(isCubeComplete()); + const GLint levelIndex = imageIndex.getLevelIndex(); + return getImageDesc(kCubeMapTextureTargetMin, levelIndex); + } + + return getImageDesc(imageIndex.getTarget(), imageIndex.getLevelIndex()); +} + +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(baseSize.width >> relativeLevel, 1), + std::max(baseSize.height >> relativeLevel, 1), + (IsArrayTextureType(mType)) + ? baseSize.depth + : std::max(baseSize.depth >> relativeLevel, 1)); + ImageDesc levelInfo(levelSize, format, initState); + + if (mType == TextureType::CubeMap) + { + for (TextureTarget face : AllCubeFaceTextureTargets()) + { + setImageDesc(face, level, levelInfo); + } + } + else + { + setImageDesc(NonCubeTextureTypeToTarget(mType), level, levelInfo); + } + } +} + +void TextureState::setImageDescChainMultisample(Extents baseSize, + const Format &format, + GLsizei samples, + bool fixedSampleLocations, + InitState initState) +{ + ASSERT(mType == TextureType::_2DMultisample || mType == TextureType::_2DMultisampleArray); + ImageDesc levelInfo(baseSize, format, samples, fixedSampleLocations, initState); + setImageDesc(NonCubeTextureTypeToTarget(mType), 0, levelInfo); +} + +void TextureState::clearImageDesc(TextureTarget 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, TextureID id, TextureType type) + : RefCountObject(factory->generateSerial(), id), + mState(type), + mTexture(factory->createTexture(mState)), + mImplObserver(this, rx::kTextureImageImplObserverMessageIndex), + mBufferObserver(this, kBufferSubjectIndex), + mBoundSurface(nullptr), + mBoundStream(nullptr) +{ + mImplObserver.bind(mTexture); + + // Initially assume the implementation is dirty. + mDirtyBits.set(DIRTY_BIT_IMPLEMENTATION); +} + +void Texture::onDestroy(const Context *context) +{ + if (mBoundSurface) + { + ANGLE_SWALLOW_ERR(mBoundSurface->releaseTexImage(context, EGL_BACK_BUFFER)); + mBoundSurface = nullptr; + } + if (mBoundStream) + { + mBoundStream->releaseTextures(); + mBoundStream = nullptr; + } + + egl::RefCountObjectReleaser releaseImage; + (void)orphanImages(context, &releaseImage); + + mState.mBuffer.set(context, nullptr, 0, 0); + + if (mTexture) + { + mTexture->onDestroy(context); + } +} + +Texture::~Texture() +{ + SafeDelete(mTexture); +} + +angle::Result Texture::setLabel(const Context *context, const std::string &label) +{ + mState.mLabel = label; + return mTexture->onLabelUpdate(context); +} + +const std::string &Texture::getLabel() const +{ + return mState.mLabel; +} + +void Texture::setSwizzleRed(const Context *context, GLenum swizzleRed) +{ + if (mState.mSwizzleState.swizzleRed != swizzleRed) + { + mState.mSwizzleState.swizzleRed = swizzleRed; + signalDirtyState(DIRTY_BIT_SWIZZLE_RED); + } +} + +GLenum Texture::getSwizzleRed() const +{ + return mState.mSwizzleState.swizzleRed; +} + +void Texture::setSwizzleGreen(const Context *context, GLenum swizzleGreen) +{ + if (mState.mSwizzleState.swizzleGreen != swizzleGreen) + { + mState.mSwizzleState.swizzleGreen = swizzleGreen; + signalDirtyState(DIRTY_BIT_SWIZZLE_GREEN); + } +} + +GLenum Texture::getSwizzleGreen() const +{ + return mState.mSwizzleState.swizzleGreen; +} + +void Texture::setSwizzleBlue(const Context *context, GLenum swizzleBlue) +{ + if (mState.mSwizzleState.swizzleBlue != swizzleBlue) + { + mState.mSwizzleState.swizzleBlue = swizzleBlue; + signalDirtyState(DIRTY_BIT_SWIZZLE_BLUE); + } +} + +GLenum Texture::getSwizzleBlue() const +{ + return mState.mSwizzleState.swizzleBlue; +} + +void Texture::setSwizzleAlpha(const Context *context, GLenum swizzleAlpha) +{ + if (mState.mSwizzleState.swizzleAlpha != swizzleAlpha) + { + mState.mSwizzleState.swizzleAlpha = swizzleAlpha; + signalDirtyState(DIRTY_BIT_SWIZZLE_ALPHA); + } +} + +GLenum Texture::getSwizzleAlpha() const +{ + return mState.mSwizzleState.swizzleAlpha; +} + +void Texture::setMinFilter(const Context *context, GLenum minFilter) +{ + if (mState.mSamplerState.setMinFilter(minFilter)) + { + signalDirtyState(DIRTY_BIT_MIN_FILTER); + } +} + +GLenum Texture::getMinFilter() const +{ + return mState.mSamplerState.getMinFilter(); +} + +void Texture::setMagFilter(const Context *context, GLenum magFilter) +{ + if (mState.mSamplerState.setMagFilter(magFilter)) + { + signalDirtyState(DIRTY_BIT_MAG_FILTER); + } +} + +GLenum Texture::getMagFilter() const +{ + return mState.mSamplerState.getMagFilter(); +} + +void Texture::setWrapS(const Context *context, GLenum wrapS) +{ + if (mState.mSamplerState.setWrapS(wrapS)) + { + signalDirtyState(DIRTY_BIT_WRAP_S); + } +} + +GLenum Texture::getWrapS() const +{ + return mState.mSamplerState.getWrapS(); +} + +void Texture::setWrapT(const Context *context, GLenum wrapT) +{ + if (mState.mSamplerState.getWrapT() == wrapT) + return; + if (mState.mSamplerState.setWrapT(wrapT)) + { + signalDirtyState(DIRTY_BIT_WRAP_T); + } +} + +GLenum Texture::getWrapT() const +{ + return mState.mSamplerState.getWrapT(); +} + +void Texture::setWrapR(const Context *context, GLenum wrapR) +{ + if (mState.mSamplerState.setWrapR(wrapR)) + { + signalDirtyState(DIRTY_BIT_WRAP_R); + } +} + +GLenum Texture::getWrapR() const +{ + return mState.mSamplerState.getWrapR(); +} + +void Texture::setMaxAnisotropy(const Context *context, float maxAnisotropy) +{ + if (mState.mSamplerState.setMaxAnisotropy(maxAnisotropy)) + { + signalDirtyState(DIRTY_BIT_MAX_ANISOTROPY); + } +} + +float Texture::getMaxAnisotropy() const +{ + return mState.mSamplerState.getMaxAnisotropy(); +} + +void Texture::setMinLod(const Context *context, GLfloat minLod) +{ + if (mState.mSamplerState.setMinLod(minLod)) + { + signalDirtyState(DIRTY_BIT_MIN_LOD); + } +} + +GLfloat Texture::getMinLod() const +{ + return mState.mSamplerState.getMinLod(); +} + +void Texture::setMaxLod(const Context *context, GLfloat maxLod) +{ + if (mState.mSamplerState.setMaxLod(maxLod)) + { + signalDirtyState(DIRTY_BIT_MAX_LOD); + } +} + +GLfloat Texture::getMaxLod() const +{ + return mState.mSamplerState.getMaxLod(); +} + +void Texture::setCompareMode(const Context *context, GLenum compareMode) +{ + if (mState.mSamplerState.setCompareMode(compareMode)) + { + signalDirtyState(DIRTY_BIT_COMPARE_MODE); + } +} + +GLenum Texture::getCompareMode() const +{ + return mState.mSamplerState.getCompareMode(); +} + +void Texture::setCompareFunc(const Context *context, GLenum compareFunc) +{ + if (mState.mSamplerState.setCompareFunc(compareFunc)) + { + signalDirtyState(DIRTY_BIT_COMPARE_FUNC); + } +} + +GLenum Texture::getCompareFunc() const +{ + return mState.mSamplerState.getCompareFunc(); +} + +void Texture::setSRGBDecode(const Context *context, GLenum sRGBDecode) +{ + if (mState.mSamplerState.setSRGBDecode(sRGBDecode)) + { + signalDirtyState(DIRTY_BIT_SRGB_DECODE); + } +} + +GLenum Texture::getSRGBDecode() const +{ + return mState.mSamplerState.getSRGBDecode(); +} + +void Texture::setSRGBOverride(const Context *context, GLenum sRGBOverride) +{ + SrgbOverride oldOverride = mState.mSrgbOverride; + mState.mSrgbOverride = (sRGBOverride == GL_SRGB) ? SrgbOverride::SRGB : SrgbOverride::Default; + if (mState.mSrgbOverride != oldOverride) + { + signalDirtyState(DIRTY_BIT_SRGB_OVERRIDE); + } +} + +GLenum Texture::getSRGBOverride() const +{ + return (mState.mSrgbOverride == SrgbOverride::SRGB) ? GL_SRGB : GL_NONE; +} + +const SamplerState &Texture::getSamplerState() const +{ + return mState.mSamplerState; +} + +angle::Result Texture::setBaseLevel(const Context *context, GLuint baseLevel) +{ + if (mState.setBaseLevel(baseLevel)) + { + ANGLE_TRY(mTexture->setBaseLevel(context, mState.getEffectiveBaseLevel())); + signalDirtyState(DIRTY_BIT_BASE_LEVEL); + } + + return angle::Result::Continue; +} + +GLuint Texture::getBaseLevel() const +{ + return mState.mBaseLevel; +} + +void Texture::setMaxLevel(const Context *context, GLuint maxLevel) +{ + if (mState.setMaxLevel(maxLevel)) + { + signalDirtyState(DIRTY_BIT_MAX_LEVEL); + } +} + +GLuint Texture::getMaxLevel() const +{ + return mState.mMaxLevel; +} + +void Texture::setDepthStencilTextureMode(const Context *context, GLenum mode) +{ + if (mState.mDepthStencilTextureMode != mode) + { + mState.mDepthStencilTextureMode = mode; + signalDirtyState(DIRTY_BIT_DEPTH_STENCIL_TEXTURE_MODE); + } +} + +GLenum Texture::getDepthStencilTextureMode() const +{ + return mState.mDepthStencilTextureMode; +} + +bool Texture::getImmutableFormat() const +{ + return mState.mImmutableFormat; +} + +GLuint Texture::getImmutableLevels() const +{ + return mState.mImmutableLevels; +} + +void Texture::setUsage(const Context *context, GLenum usage) +{ + mState.mUsage = usage; + signalDirtyState(DIRTY_BIT_USAGE); +} + +GLenum Texture::getUsage() const +{ + return mState.mUsage; +} + +void Texture::setProtectedContent(Context *context, bool hasProtectedContent) +{ + mState.mHasProtectedContent = hasProtectedContent; +} + +bool Texture::hasProtectedContent() const +{ + return mState.mHasProtectedContent; +} + +const TextureState &Texture::getTextureState() const +{ + return mState; +} + +const Extents &Texture::getExtents(TextureTarget target, size_t level) const +{ + ASSERT(TextureTargetToType(target) == mState.mType); + return mState.getImageDesc(target, level).size; +} + +size_t Texture::getWidth(TextureTarget target, size_t level) const +{ + ASSERT(TextureTargetToType(target) == mState.mType); + return mState.getImageDesc(target, level).size.width; +} + +size_t Texture::getHeight(TextureTarget target, size_t level) const +{ + ASSERT(TextureTargetToType(target) == mState.mType); + return mState.getImageDesc(target, level).size.height; +} + +size_t Texture::getDepth(TextureTarget target, size_t level) const +{ + ASSERT(TextureTargetToType(target) == mState.mType); + return mState.getImageDesc(target, level).size.depth; +} + +const Format &Texture::getFormat(TextureTarget target, size_t level) const +{ + ASSERT(TextureTargetToType(target) == mState.mType); + return mState.getImageDesc(target, level).format; +} + +GLsizei Texture::getSamples(TextureTarget target, size_t level) const +{ + ASSERT(TextureTargetToType(target) == mState.mType); + return mState.getImageDesc(target, level).samples; +} + +bool Texture::getFixedSampleLocations(TextureTarget target, size_t level) const +{ + ASSERT(TextureTargetToType(target) == mState.mType); + return mState.getImageDesc(target, level).fixedSampleLocations; +} + +GLuint Texture::getMipmapMaxLevel() const +{ + return mState.getMipmapMaxLevel(); +} + +bool Texture::isMipmapComplete() const +{ + return mState.computeMipmapCompleteness(); +} + +egl::Surface *Texture::getBoundSurface() const +{ + return mBoundSurface; +} + +egl::Stream *Texture::getBoundStream() const +{ + return mBoundStream; +} + +GLint Texture::getMemorySize() const +{ + GLint implSize = mTexture->getMemorySize(); + if (implSize > 0) + { + return implSize; + } + + angle::CheckedNumeric size = 0; + for (const ImageDesc &imageDesc : mState.mImageDescs) + { + size += imageDesc.getMemorySize(); + } + return size.ValueOrDefault(std::numeric_limits::max()); +} + +GLint Texture::getLevelMemorySize(TextureTarget target, GLint level) const +{ + GLint implSize = mTexture->getLevelMemorySize(target, level); + if (implSize > 0) + { + return implSize; + } + + return mState.getImageDesc(target, level).getMemorySize(); +} + +void Texture::signalDirtyStorage(InitState initState) +{ + mState.mInitState = initState; + invalidateCompletenessCache(); + mState.mCachedSamplerFormatValid = false; + onStateChange(angle::SubjectMessage::SubjectChanged); +} + +void Texture::signalDirtyState(size_t dirtyBit) +{ + mDirtyBits.set(dirtyBit); + invalidateCompletenessCache(); + mState.mCachedSamplerFormatValid = false; + + if (dirtyBit == DIRTY_BIT_BASE_LEVEL || dirtyBit == DIRTY_BIT_MAX_LEVEL) + { + onStateChange(angle::SubjectMessage::SubjectChanged); + } + else + { + onStateChange(angle::SubjectMessage::DirtyBitsFlagged); + } +} + +angle::Result Texture::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) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth); + + ANGLE_TRY(mTexture->setImage(context, index, internalFormat, size, format, type, unpackState, + unpackBuffer, pixels)); + + InitState initState = DetermineInitState(context, unpackBuffer, pixels); + mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat, type), initState)); + + ANGLE_TRY(handleMipmapGenerationHint(context, level)); + + signalDirtyStorage(initState); + + return angle::Result::Continue; +} + +angle::Result Texture::setSubImage(Context *context, + const PixelUnpackState &unpackState, + Buffer *unpackBuffer, + TextureTarget target, + GLint level, + const Box &area, + GLenum format, + GLenum type, + const uint8_t *pixels) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + + ImageIndex index = ImageIndex::MakeFromTarget(target, level, area.depth); + ANGLE_TRY(ensureSubImageInitialized(context, index, area)); + + ANGLE_TRY(mTexture->setSubImage(context, index, area, format, type, unpackState, unpackBuffer, + pixels)); + + ANGLE_TRY(handleMipmapGenerationHint(context, level)); + + onStateChange(angle::SubjectMessage::ContentsChanged); + + return angle::Result::Continue; +} + +angle::Result Texture::setCompressedImage(Context *context, + const PixelUnpackState &unpackState, + TextureTarget target, + GLint level, + GLenum internalFormat, + const Extents &size, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth); + + ANGLE_TRY(mTexture->setCompressedImage(context, index, internalFormat, size, unpackState, + imageSize, pixels)); + + Buffer *unpackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelUnpack); + + InitState initState = DetermineInitState(context, unpackBuffer, pixels); + mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat), initState)); + signalDirtyStorage(initState); + + return angle::Result::Continue; +} + +angle::Result Texture::setCompressedSubImage(const Context *context, + const PixelUnpackState &unpackState, + TextureTarget target, + GLint level, + const Box &area, + GLenum format, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + + ImageIndex index = ImageIndex::MakeFromTarget(target, level, area.depth); + ANGLE_TRY(ensureSubImageInitialized(context, index, area)); + + ANGLE_TRY(mTexture->setCompressedSubImage(context, index, area, format, unpackState, imageSize, + pixels)); + + onStateChange(angle::SubjectMessage::ContentsChanged); + + return angle::Result::Continue; +} + +angle::Result Texture::copyImage(Context *context, + TextureTarget target, + GLint level, + const Rectangle &sourceArea, + GLenum internalFormat, + Framebuffer *source) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + ImageIndex index = ImageIndex::MakeFromTarget(target, level, 1); + + const InternalFormat &internalFormatInfo = + GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE); + + // Most if not all renderers clip these copies to the size of the source framebuffer, leaving + // other pixels untouched. For safety in robust resource initialization, assume that that + // clipping is going to occur when computing the region for which to ensure initialization. If + // the copy lies entirely off the source framebuffer, initialize as though a zero-size box is + // going to be set during the copy operation. + Box destBox; + bool forceCopySubImage = false; + if (context->isRobustResourceInitEnabled()) + { + const FramebufferAttachment *sourceReadAttachment = source->getReadColorAttachment(); + Extents fbSize = sourceReadAttachment->getSize(); + // Force using copySubImage when the source area is out of bounds AND + // we're not copying to and from the same texture + forceCopySubImage = ((sourceArea.x < 0) || (sourceArea.y < 0) || + ((sourceArea.x + sourceArea.width) > fbSize.width) || + ((sourceArea.y + sourceArea.height) > fbSize.height)) && + (sourceReadAttachment->getResource() != this); + Rectangle clippedArea; + if (ClipRectangle(sourceArea, Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea)) + { + const Offset clippedOffset(clippedArea.x - sourceArea.x, clippedArea.y - sourceArea.y, + 0); + destBox = Box(clippedOffset.x, clippedOffset.y, clippedOffset.z, clippedArea.width, + clippedArea.height, 1); + } + } + + InitState initState = DetermineInitState(context, nullptr, nullptr); + + // If we need to initialize the destination texture we split the call into a create call, + // an initializeContents call, and then a copySubImage call. This ensures the destination + // texture exists before we try to clear it. + Extents size(sourceArea.width, sourceArea.height, 1); + if (forceCopySubImage || doesSubImageNeedInit(context, index, destBox)) + { + ANGLE_TRY(mTexture->setImage(context, index, internalFormat, size, + internalFormatInfo.format, internalFormatInfo.type, + PixelUnpackState(), nullptr, nullptr)); + mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormatInfo), initState)); + ANGLE_TRY(ensureSubImageInitialized(context, index, destBox)); + ANGLE_TRY(mTexture->copySubImage(context, index, Offset(), sourceArea, source)); + } + else + { + ANGLE_TRY(mTexture->copyImage(context, index, sourceArea, internalFormat, source)); + } + + mState.setImageDesc(target, level, + ImageDesc(size, Format(internalFormatInfo), InitState::Initialized)); + + ANGLE_TRY(handleMipmapGenerationHint(context, level)); + + // Because this could affect the texture storage we might need to init other layers/levels. + signalDirtyStorage(initState); + + return angle::Result::Continue; +} + +angle::Result Texture::copySubImage(Context *context, + const ImageIndex &index, + const Offset &destOffset, + const Rectangle &sourceArea, + Framebuffer *source) +{ + ASSERT(TextureTargetToType(index.getTarget()) == mState.mType); + + // Most if not all renderers clip these copies to the size of the source framebuffer, leaving + // other pixels untouched. For safety in robust resource initialization, assume that that + // clipping is going to occur when computing the region for which to ensure initialization. If + // the copy lies entirely off the source framebuffer, initialize as though a zero-size box is + // going to be set during the copy operation. Note that this assumes that + // ensureSubImageInitialized ensures initialization of the entire destination texture, and not + // just a sub-region. + Box destBox; + if (context->isRobustResourceInitEnabled()) + { + Extents fbSize = source->getReadColorAttachment()->getSize(); + Rectangle clippedArea; + if (ClipRectangle(sourceArea, Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea)) + { + const Offset clippedOffset(destOffset.x + clippedArea.x - sourceArea.x, + destOffset.y + clippedArea.y - sourceArea.y, 0); + destBox = Box(clippedOffset.x, clippedOffset.y, clippedOffset.z, clippedArea.width, + clippedArea.height, 1); + } + } + + ANGLE_TRY(ensureSubImageInitialized(context, index, destBox)); + + ANGLE_TRY(mTexture->copySubImage(context, index, destOffset, sourceArea, source)); + ANGLE_TRY(handleMipmapGenerationHint(context, index.getLevelIndex())); + + onStateChange(angle::SubjectMessage::ContentsChanged); + + return angle::Result::Continue; +} + +angle::Result Texture::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_TRY(mTexture->copyRenderbufferSubData(context, srcBuffer, srcLevel, srcX, srcY, srcZ, + dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, + srcDepth)); + + signalDirtyStorage(InitState::Initialized); + + return angle::Result::Continue; +} + +angle::Result Texture::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_TRY(mTexture->copyTextureSubData(context, srcTexture, srcLevel, srcX, srcY, srcZ, + dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, + srcDepth)); + + signalDirtyStorage(InitState::Initialized); + + return angle::Result::Continue; +} + +angle::Result Texture::copyTexture(Context *context, + TextureTarget target, + GLint level, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + Texture *source) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + ASSERT(source->getType() != TextureType::CubeMap); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + // Initialize source texture. + // Note: we don't have a way to notify which portions of the image changed currently. + ANGLE_TRY(source->ensureInitialized(context)); + + ImageIndex index = ImageIndex::MakeFromTarget(target, level, ImageIndex::kEntireLevel); + + ANGLE_TRY(mTexture->copyTexture(context, index, internalFormat, type, sourceLevel, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha, source)); + + const auto &sourceDesc = + source->mState.getImageDesc(NonCubeTextureTypeToTarget(source->getType()), sourceLevel); + const InternalFormat &internalFormatInfo = GetInternalFormatInfo(internalFormat, type); + mState.setImageDesc( + target, level, + ImageDesc(sourceDesc.size, Format(internalFormatInfo), InitState::Initialized)); + + signalDirtyStorage(InitState::Initialized); + + return angle::Result::Continue; +} + +angle::Result Texture::copySubTexture(const Context *context, + TextureTarget target, + GLint level, + const Offset &destOffset, + GLint sourceLevel, + const Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + Texture *source) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + + // Ensure source is initialized. + ANGLE_TRY(source->ensureInitialized(context)); + + Box destBox(destOffset.x, destOffset.y, destOffset.z, sourceBox.width, sourceBox.height, + sourceBox.depth); + ImageIndex index = ImageIndex::MakeFromTarget(target, level, sourceBox.depth); + ANGLE_TRY(ensureSubImageInitialized(context, index, destBox)); + + ANGLE_TRY(mTexture->copySubTexture(context, index, destOffset, sourceLevel, sourceBox, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha, + source)); + + onStateChange(angle::SubjectMessage::ContentsChanged); + + return angle::Result::Continue; +} + +angle::Result Texture::copyCompressedTexture(Context *context, const Texture *source) +{ + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + ANGLE_TRY(mTexture->copyCompressedTexture(context, source)); + + ASSERT(source->getType() != TextureType::CubeMap && getType() != TextureType::CubeMap); + const auto &sourceDesc = + source->mState.getImageDesc(NonCubeTextureTypeToTarget(source->getType()), 0); + mState.setImageDesc(NonCubeTextureTypeToTarget(getType()), 0, sourceDesc); + + return angle::Result::Continue; +} + +angle::Result Texture::setStorage(Context *context, + TextureType type, + GLsizei levels, + GLenum internalFormat, + const Extents &size) +{ + ASSERT(type == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + mState.mImmutableFormat = true; + mState.mImmutableLevels = static_cast(levels); + mState.clearImageDescs(); + InitState initState = DetermineInitState(context, nullptr, nullptr); + mState.setImageDescChain(0, static_cast(levels - 1), size, Format(internalFormat), + initState); + + ANGLE_TRY(mTexture->setStorage(context, type, levels, internalFormat, size)); + + // 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); + + signalDirtyStorage(initState); + + return angle::Result::Continue; +} + +angle::Result Texture::setImageExternal(Context *context, + TextureTarget target, + GLint level, + GLenum internalFormat, + const Extents &size, + GLenum format, + GLenum type) +{ + ASSERT(TextureTargetToType(target) == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth); + + ANGLE_TRY(mTexture->setImageExternal(context, index, internalFormat, size, format, type)); + + InitState initState = InitState::Initialized; + mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat, type), initState)); + + ANGLE_TRY(handleMipmapGenerationHint(context, level)); + + signalDirtyStorage(initState); + + return angle::Result::Continue; +} + +angle::Result Texture::setStorageMultisample(Context *context, + TextureType type, + GLsizei samplesIn, + GLint internalFormat, + const Extents &size, + bool fixedSampleLocations) +{ + ASSERT(type == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + // Potentially adjust "samples" to a supported value + const TextureCaps &formatCaps = context->getTextureCaps().get(internalFormat); + GLsizei samples = formatCaps.getNearestSamples(samplesIn); + + mState.mImmutableFormat = true; + mState.mImmutableLevels = static_cast(1); + mState.clearImageDescs(); + InitState initState = DetermineInitState(context, nullptr, nullptr); + mState.setImageDescChainMultisample(size, Format(internalFormat), samples, fixedSampleLocations, + initState); + + ANGLE_TRY(mTexture->setStorageMultisample(context, type, samples, internalFormat, size, + fixedSampleLocations)); + signalDirtyStorage(initState); + + return angle::Result::Continue; +} + +angle::Result Texture::setStorageExternalMemory(Context *context, + TextureType type, + GLsizei levels, + GLenum internalFormat, + const Extents &size, + MemoryObject *memoryObject, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + ASSERT(type == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + ANGLE_TRY(mTexture->setStorageExternalMemory(context, type, levels, internalFormat, size, + memoryObject, offset, createFlags, usageFlags, + imageCreateInfoPNext)); + + mState.mImmutableFormat = true; + mState.mImmutableLevels = static_cast(levels); + mState.clearImageDescs(); + mState.setImageDescChain(0, static_cast(levels - 1), size, Format(internalFormat), + InitState::Initialized); + + // 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); + + signalDirtyStorage(InitState::Initialized); + + return angle::Result::Continue; +} + +angle::Result Texture::generateMipmap(Context *context) +{ + // 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. + egl::RefCountObjectReleaser releaseImage; + if (!isMipmapComplete()) + { + ANGLE_TRY(orphanImages(context, &releaseImage)); + } + + const GLuint baseLevel = mState.getEffectiveBaseLevel(); + const GLuint maxLevel = mState.getMipmapMaxLevel(); + + if (maxLevel <= baseLevel) + { + return angle::Result::Continue; + } + + // If any dimension is zero, this is a no-op: + // + // > Otherwise, if level_base is not defined, or if any dimension is zero, all mipmap levels are + // > left unchanged. This is not an error. + const ImageDesc &baseImageInfo = mState.getImageDesc(mState.getBaseImageTarget(), baseLevel); + if (baseImageInfo.size.empty()) + { + return angle::Result::Continue; + } + + // Clear the base image(s) immediately if needed + if (context->isRobustResourceInitEnabled()) + { + ImageIndexIterator it = + ImageIndexIterator::MakeGeneric(mState.mType, baseLevel, baseLevel + 1, + ImageIndex::kEntireLevel, ImageIndex::kEntireLevel); + while (it.hasNext()) + { + const ImageIndex index = it.next(); + const ImageDesc &desc = mState.getImageDesc(index.getTarget(), index.getLevelIndex()); + + if (desc.initState == InitState::MayNeedInit) + { + ANGLE_TRY(initializeContents(context, GL_NONE, index)); + } + } + } + + ANGLE_TRY(syncState(context, Command::GenerateMipmap)); + ANGLE_TRY(mTexture->generateMipmap(context)); + + // Propagate the format and size of the base mip to the smaller ones. Cube maps are guaranteed + // to have faces of the same size and format so any faces can be picked. + mState.setImageDescChain(baseLevel, maxLevel, baseImageInfo.size, baseImageInfo.format, + InitState::Initialized); + + signalDirtyStorage(InitState::Initialized); + + return angle::Result::Continue; +} + +angle::Result Texture::bindTexImageFromSurface(Context *context, egl::Surface *surface) +{ + ASSERT(surface); + + if (mBoundSurface) + { + ANGLE_TRY(releaseTexImageFromSurface(context)); + } + + mBoundSurface = surface; + + // Set the image info to the size and format of the surface + ASSERT(mState.mType == TextureType::_2D || mState.mType == TextureType::Rectangle); + Extents size(surface->getWidth(), surface->getHeight(), 1); + ImageDesc desc(size, surface->getBindTexImageFormat(), InitState::Initialized); + mState.setImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0, desc); + mState.mHasProtectedContent = surface->hasProtectedContent(); + + ANGLE_TRY(mTexture->bindTexImage(context, surface)); + + signalDirtyStorage(InitState::Initialized); + return angle::Result::Continue; +} + +angle::Result Texture::releaseTexImageFromSurface(const Context *context) +{ + ASSERT(mBoundSurface); + mBoundSurface = nullptr; + ANGLE_TRY(mTexture->releaseTexImage(context)); + + // Erase the image info for level 0 + ASSERT(mState.mType == TextureType::_2D || mState.mType == TextureType::Rectangle); + mState.clearImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0); + mState.mHasProtectedContent = false; + signalDirtyStorage(InitState::Initialized); + return angle::Result::Continue; +} + +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.mType == TextureType::External); +} + +void Texture::releaseStream() +{ + ASSERT(mBoundStream); + mBoundStream = nullptr; +} + +angle::Result Texture::acquireImageFromStream(const Context *context, + const egl::Stream::GLTextureDescription &desc) +{ + ASSERT(mBoundStream != nullptr); + ANGLE_TRY(mTexture->setImageExternal(context, mState.mType, mBoundStream, desc)); + + Extents size(desc.width, desc.height, 1); + mState.setImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0, + ImageDesc(size, Format(desc.internalFormat), InitState::Initialized)); + signalDirtyStorage(InitState::Initialized); + return angle::Result::Continue; +} + +angle::Result Texture::releaseImageFromStream(const Context *context) +{ + ASSERT(mBoundStream != nullptr); + ANGLE_TRY(mTexture->setImageExternal(context, mState.mType, nullptr, + egl::Stream::GLTextureDescription())); + + // Set to incomplete + mState.clearImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0); + signalDirtyStorage(InitState::Initialized); + return angle::Result::Continue; +} + +angle::Result Texture::releaseTexImageInternal(Context *context) +{ + if (mBoundSurface) + { + // Notify the surface + egl::Error eglErr = mBoundSurface->releaseTexImageFromTexture(context); + // TODO(jmadill): Remove this once refactor is complete. http://anglebug.com/3041 + if (eglErr.isError()) + { + context->handleError(GL_INVALID_OPERATION, "Error releasing tex image from texture", + __FILE__, ANGLE_FUNCTION, __LINE__); + } + + // Then, call the same method as from the surface + ANGLE_TRY(releaseTexImageFromSurface(context)); + } + return angle::Result::Continue; +} + +angle::Result Texture::setEGLImageTargetImpl(Context *context, + TextureType type, + GLuint levels, + egl::Image *imageTarget) +{ + ASSERT(type == mState.mType); + + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + ANGLE_TRY(releaseTexImageInternal(context)); + + egl::RefCountObjectReleaser releaseImage; + ANGLE_TRY(orphanImages(context, &releaseImage)); + + setTargetImage(context, imageTarget); + + auto initState = imageTarget->sourceInitState(); + + mState.clearImageDescs(); + mState.setImageDescChain(0, levels - 1, imageTarget->getExtents(), imageTarget->getFormat(), + initState); + mState.mHasProtectedContent = imageTarget->hasProtectedContent(); + + ANGLE_TRY(mTexture->setEGLImageTarget(context, type, imageTarget)); + + signalDirtyStorage(initState); + + return angle::Result::Continue; +} + +angle::Result Texture::setEGLImageTarget(Context *context, + TextureType type, + egl::Image *imageTarget) +{ + ASSERT(type == TextureType::_2D || type == TextureType::External || + type == TextureType::_2DArray); + + return setEGLImageTargetImpl(context, type, 1u, imageTarget); +} + +angle::Result Texture::setStorageEGLImageTarget(Context *context, + TextureType type, + egl::Image *imageTarget, + const GLint *attrib_list) +{ + ASSERT(type == TextureType::External || type == TextureType::_3D || type == TextureType::_2D || + type == TextureType::_2DArray || type == TextureType::CubeMap || + type == TextureType::CubeMapArray); + + ANGLE_TRY(setEGLImageTargetImpl(context, type, imageTarget->getLevelCount(), imageTarget)); + + mState.mImmutableLevels = imageTarget->getLevelCount(); + mState.mImmutableFormat = true; + + // 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); + + return angle::Result::Continue; +} + +Extents Texture::getAttachmentSize(const ImageIndex &imageIndex) const +{ + // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs, + // we only allow querying ImageDesc on a complete cube map, and this ImageDesc is exactly the + // one that belongs to the first face of the cube map. + if (imageIndex.isEntireLevelCubeMap()) + { + // A cube map texture is cube complete if the following conditions all hold true: + // - The levelbase arrays of each of the six texture images making up the cube map have + // identical, positive, and square dimensions. + if (!mState.isCubeComplete()) + { + return Extents(); + } + } + + return mState.getImageDesc(imageIndex).size; +} + +Format Texture::getAttachmentFormat(GLenum /*binding*/, const ImageIndex &imageIndex) const +{ + // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs, + // we only allow querying ImageDesc on a complete cube map, and this ImageDesc is exactly the + // one that belongs to the first face of the cube map. + if (imageIndex.isEntireLevelCubeMap()) + { + // A cube map texture is cube complete if the following conditions all hold true: + // - The levelbase arrays were each specified with the same effective internal format. + if (!mState.isCubeComplete()) + { + return Format::Invalid(); + } + } + return mState.getImageDesc(imageIndex).format; +} + +GLsizei Texture::getAttachmentSamples(const ImageIndex &imageIndex) const +{ + // We do not allow querying TextureTarget by an ImageIndex that represents an entire level of a + // cube map (See comments in function TextureTypeToTarget() in ImageIndex.cpp). + if (imageIndex.isEntireLevelCubeMap()) + { + return 0; + } + + return getSamples(imageIndex.getTarget(), imageIndex.getLevelIndex()); +} + +bool Texture::isRenderable(const Context *context, + GLenum binding, + const ImageIndex &imageIndex) const +{ + if (isEGLImageTarget()) + { + return ImageSibling::isRenderable(context, binding, imageIndex); + } + + // Surfaces bound to textures are always renderable. This avoids issues with surfaces with ES3+ + // formats not being renderable when bound to textures in ES2 contexts. + if (mBoundSurface) + { + return true; + } + + return getAttachmentFormat(binding, imageIndex) + .info->textureAttachmentSupport(context->getClientVersion(), context->getExtensions()); +} + +bool Texture::getAttachmentFixedSampleLocations(const ImageIndex &imageIndex) const +{ + // We do not allow querying TextureTarget by an ImageIndex that represents an entire level of a + // cube map (See comments in function TextureTypeToTarget() in ImageIndex.cpp). + if (imageIndex.isEntireLevelCubeMap()) + { + return true; + } + + // ES3.1 (section 9.4) requires that the value of TEXTURE_FIXED_SAMPLE_LOCATIONS should be + // the same for all attached textures. + return getFixedSampleLocations(imageIndex.getTarget(), imageIndex.getLevelIndex()); +} + +void Texture::setBorderColor(const Context *context, const ColorGeneric &color) +{ + mState.mSamplerState.setBorderColor(color); + signalDirtyState(DIRTY_BIT_BORDER_COLOR); +} + +const ColorGeneric &Texture::getBorderColor() const +{ + return mState.mSamplerState.getBorderColor(); +} + +GLint Texture::getRequiredTextureImageUnits(const Context *context) const +{ + // Only external texture types can return non-1. + if (mState.mType != TextureType::External) + { + return 1; + } + + return mTexture->getRequiredExternalTextureImageUnits(context); +} + +void Texture::setCrop(const Rectangle &rect) +{ + mState.setCrop(rect); +} + +const Rectangle &Texture::getCrop() const +{ + return mState.getCrop(); +} + +void Texture::setGenerateMipmapHint(GLenum hint) +{ + mState.setGenerateMipmapHint(hint); +} + +GLenum Texture::getGenerateMipmapHint() const +{ + return mState.getGenerateMipmapHint(); +} + +angle::Result Texture::setBuffer(const gl::Context *context, + gl::Buffer *buffer, + GLenum internalFormat) +{ + // Use 0 to indicate that the size is taken from whatever size the buffer has when the texture + // buffer is used. + return setBufferRange(context, buffer, internalFormat, 0, 0); +} + +angle::Result Texture::setBufferRange(const gl::Context *context, + gl::Buffer *buffer, + GLenum internalFormat, + GLintptr offset, + GLsizeiptr size) +{ + mState.mImmutableFormat = true; + mState.mBuffer.set(context, buffer, offset, size); + ANGLE_TRY(mTexture->setBuffer(context, internalFormat)); + + mState.clearImageDescs(); + if (buffer == nullptr) + { + mBufferObserver.reset(); + InitState initState = DetermineInitState(context, nullptr, nullptr); + signalDirtyStorage(initState); + return angle::Result::Continue; + } + + size = GetBoundBufferAvailableSize(mState.mBuffer); + + mState.mImmutableLevels = static_cast(1); + InternalFormat internalFormatInfo = GetSizedInternalFormatInfo(internalFormat); + Format format(internalFormat); + Extents extents(static_cast(size / internalFormatInfo.pixelBytes), 1, 1); + InitState initState = buffer->initState(); + mState.setImageDesc(TextureTarget::Buffer, 0, ImageDesc(extents, format, initState)); + + signalDirtyStorage(initState); + + // Observe modifications to the buffer, so that extents can be updated. + mBufferObserver.bind(buffer); + + return angle::Result::Continue; +} + +const OffsetBindingPointer &Texture::getBuffer() const +{ + return mState.mBuffer; +} + +void Texture::onAttach(const Context *context, rx::Serial framebufferSerial) +{ + addRef(); + + // Duplicates allowed for multiple attachment points. See the comment in the header. + mBoundFramebufferSerials.push_back(framebufferSerial); + + if (!mState.mHasBeenBoundAsAttachment) + { + mDirtyBits.set(DIRTY_BIT_BOUND_AS_ATTACHMENT); + mState.mHasBeenBoundAsAttachment = true; + } +} + +void Texture::onDetach(const Context *context, rx::Serial framebufferSerial) +{ + // Erase first instance. If there are multiple bindings, leave the others. + ASSERT(isBoundToFramebuffer(framebufferSerial)); + mBoundFramebufferSerials.remove_and_permute(framebufferSerial); + + release(context); +} + +GLuint Texture::getId() const +{ + return id().value; +} + +GLuint Texture::getNativeID() const +{ + return mTexture->getNativeID(); +} + +angle::Result Texture::syncState(const Context *context, Command source) +{ + ASSERT(hasAnyDirtyBit() || source == Command::GenerateMipmap); + ANGLE_TRY(mTexture->syncState(context, mDirtyBits, source)); + mDirtyBits.reset(); + mState.mInitState = InitState::Initialized; + return angle::Result::Continue; +} + +rx::FramebufferAttachmentObjectImpl *Texture::getAttachmentImpl() const +{ + return mTexture; +} + +bool Texture::isSamplerComplete(const Context *context, const Sampler *optionalSampler) +{ + const auto &samplerState = + optionalSampler ? optionalSampler->getSamplerState() : mState.mSamplerState; + const auto &contextState = context->getState(); + + if (contextState.getContextID() != mCompletenessCache.context || + !mCompletenessCache.samplerState.sameCompleteness(samplerState)) + { + mCompletenessCache.context = context->getState().getContextID(); + mCompletenessCache.samplerState = samplerState; + mCompletenessCache.samplerComplete = + mState.computeSamplerCompleteness(samplerState, contextState); + } + + return mCompletenessCache.samplerComplete; +} + +// CopyImageSubData requires that we ignore format-based completeness rules +bool Texture::isSamplerCompleteForCopyImage(const Context *context, + const Sampler *optionalSampler) const +{ + const gl::SamplerState &samplerState = + optionalSampler ? optionalSampler->getSamplerState() : mState.mSamplerState; + const gl::State &contextState = context->getState(); + return mState.computeSamplerCompletenessForCopyImage(samplerState, contextState); +} + +Texture::SamplerCompletenessCache::SamplerCompletenessCache() + : context({0}), samplerState(), samplerComplete(false) +{} + +void Texture::invalidateCompletenessCache() const +{ + mCompletenessCache.context = {0}; +} + +angle::Result Texture::ensureInitialized(const Context *context) +{ + if (!context->isRobustResourceInitEnabled() || mState.mInitState == InitState::Initialized) + { + return angle::Result::Continue; + } + + bool anyDirty = false; + + ImageIndexIterator it = + ImageIndexIterator::MakeGeneric(mState.mType, 0, IMPLEMENTATION_MAX_TEXTURE_LEVELS + 1, + ImageIndex::kEntireLevel, ImageIndex::kEntireLevel); + while (it.hasNext()) + { + const ImageIndex index = it.next(); + ImageDesc &desc = + mState.mImageDescs[GetImageDescIndex(index.getTarget(), index.getLevelIndex())]; + if (desc.initState == InitState::MayNeedInit && !desc.size.empty()) + { + ASSERT(mState.mInitState == InitState::MayNeedInit); + ANGLE_TRY(initializeContents(context, GL_NONE, index)); + desc.initState = InitState::Initialized; + anyDirty = true; + } + } + if (anyDirty) + { + signalDirtyStorage(InitState::Initialized); + } + mState.mInitState = InitState::Initialized; + + return angle::Result::Continue; +} + +InitState Texture::initState(GLenum /*binding*/, const ImageIndex &imageIndex) const +{ + // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs, + // we need to check all the related ImageDescs. + if (imageIndex.isEntireLevelCubeMap()) + { + const GLint levelIndex = imageIndex.getLevelIndex(); + for (TextureTarget cubeFaceTarget : AllCubeFaceTextureTargets()) + { + if (mState.getImageDesc(cubeFaceTarget, levelIndex).initState == InitState::MayNeedInit) + { + return InitState::MayNeedInit; + } + } + return InitState::Initialized; + } + + return mState.getImageDesc(imageIndex).initState; +} + +void Texture::setInitState(GLenum binding, const ImageIndex &imageIndex, InitState initState) +{ + // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs, + // we need to update all the related ImageDescs. + if (imageIndex.isEntireLevelCubeMap()) + { + const GLint levelIndex = imageIndex.getLevelIndex(); + for (TextureTarget cubeFaceTarget : AllCubeFaceTextureTargets()) + { + setInitState(binding, ImageIndex::MakeCubeMapFace(cubeFaceTarget, levelIndex), + initState); + } + } + else + { + ImageDesc newDesc = mState.getImageDesc(imageIndex); + newDesc.initState = initState; + mState.setImageDesc(imageIndex.getTarget(), imageIndex.getLevelIndex(), newDesc); + } +} + +void Texture::setInitState(InitState initState) +{ + for (ImageDesc &imageDesc : mState.mImageDescs) + { + // Only modify defined images, undefined images will remain in the initialized state + if (!imageDesc.size.empty()) + { + imageDesc.initState = initState; + } + } + mState.mInitState = initState; +} + +bool Texture::doesSubImageNeedInit(const Context *context, + const ImageIndex &imageIndex, + const Box &area) const +{ + if (!context->isRobustResourceInitEnabled() || mState.mInitState == InitState::Initialized) + { + return false; + } + + // Pre-initialize the texture contents if necessary. + const ImageDesc &desc = mState.getImageDesc(imageIndex); + if (desc.initState != InitState::MayNeedInit) + { + return false; + } + + ASSERT(mState.mInitState == InitState::MayNeedInit); + return !area.coversSameExtent(desc.size); +} + +angle::Result Texture::ensureSubImageInitialized(const Context *context, + const ImageIndex &imageIndex, + const Box &area) +{ + if (doesSubImageNeedInit(context, imageIndex, area)) + { + // NOTE: do not optimize this to only initialize the passed area of the texture, or the + // initialization logic in copySubImage will be incorrect. + ANGLE_TRY(initializeContents(context, GL_NONE, imageIndex)); + } + // Note: binding is ignored for textures. + setInitState(GL_NONE, imageIndex, InitState::Initialized); + return angle::Result::Continue; +} + +angle::Result Texture::handleMipmapGenerationHint(Context *context, int level) +{ + if (getGenerateMipmapHint() == GL_TRUE && level == 0) + { + ANGLE_TRY(generateMipmap(context)); + } + + return angle::Result::Continue; +} + +void Texture::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) +{ + switch (message) + { + case angle::SubjectMessage::ContentsChanged: + if (index != kBufferSubjectIndex) + { + // ContentsChange originates from TextureStorage11::resolveAndReleaseTexture + // which resolves the underlying multisampled texture if it exists and so + // Texture will signal dirty storage to invalidate its own cache and the + // attached framebuffer's cache. + signalDirtyStorage(InitState::Initialized); + } + break; + case angle::SubjectMessage::DirtyBitsFlagged: + signalDirtyState(DIRTY_BIT_IMPLEMENTATION); + + // Notify siblings that we are dirty. + if (index == rx::kTextureImageImplObserverMessageIndex) + { + notifySiblings(message); + } + break; + case angle::SubjectMessage::SubjectChanged: + mState.mInitState = InitState::MayNeedInit; + signalDirtyState(DIRTY_BIT_IMPLEMENTATION); + onStateChange(angle::SubjectMessage::ContentsChanged); + + // Notify siblings that we are dirty. + if (index == rx::kTextureImageImplObserverMessageIndex) + { + notifySiblings(message); + } + else if (index == kBufferSubjectIndex) + { + const gl::Buffer *buffer = mState.mBuffer.get(); + ASSERT(buffer != nullptr); + + // Update cached image desc based on buffer size. + GLsizeiptr size = GetBoundBufferAvailableSize(mState.mBuffer); + + ImageDesc desc = mState.getImageDesc(TextureTarget::Buffer, 0); + const GLuint pixelBytes = desc.format.info->pixelBytes; + desc.size.width = static_cast(size / pixelBytes); + + mState.setImageDesc(TextureTarget::Buffer, 0, desc); + } + break; + case angle::SubjectMessage::StorageReleased: + // When the TextureStorage is released, it needs to update the + // RenderTargetCache of the Framebuffer attaching this Texture. + // This is currently only for D3D back-end. See http://crbug.com/1234829 + if (index == rx::kTextureImageImplObserverMessageIndex) + { + onStateChange(angle::SubjectMessage::StorageReleased); + } + break; + case angle::SubjectMessage::SubjectMapped: + case angle::SubjectMessage::SubjectUnmapped: + case angle::SubjectMessage::BindingChanged: + ASSERT(index == kBufferSubjectIndex); + break; + case angle::SubjectMessage::InitializationComplete: + ASSERT(index == rx::kTextureImageImplObserverMessageIndex); + setInitState(InitState::Initialized); + break; + case angle::SubjectMessage::InternalMemoryAllocationChanged: + // Need to mark the texture dirty to give the back end a chance to handle the new + // buffer. For example, the Vulkan back end needs to create a new buffer view that + // points to the newly allocated buffer and update the texture descriptor set. + signalDirtyState(DIRTY_BIT_IMPLEMENTATION); + break; + default: + UNREACHABLE(); + break; + } +} + +GLenum Texture::getImplementationColorReadFormat(const Context *context) const +{ + return mTexture->getColorReadFormat(context); +} + +GLenum Texture::getImplementationColorReadType(const Context *context) const +{ + return mTexture->getColorReadType(context); +} + +bool Texture::isCompressedFormatEmulated(const Context *context, + TextureTarget target, + GLint level) const +{ + if (!getFormat(target, level).info->compressed) + { + // If it isn't compressed, the remaining logic won't work + return false; + } + + GLenum implFormat = getImplementationColorReadFormat(context); + + // Check against the list of formats used to emulate compressed textures + return IsEmulatedCompressedFormat(implFormat); +} + +angle::Result Texture::getTexImage(const Context *context, + const PixelPackState &packState, + Buffer *packBuffer, + TextureTarget target, + GLint level, + GLenum format, + GLenum type, + void *pixels) +{ + // No-op if the image level is empty. + if (getExtents(target, level).empty()) + { + return angle::Result::Continue; + } + + return mTexture->getTexImage(context, packState, packBuffer, target, level, format, type, + pixels); +} + +angle::Result Texture::getCompressedTexImage(const Context *context, + const PixelPackState &packState, + Buffer *packBuffer, + TextureTarget target, + GLint level, + void *pixels) +{ + // No-op if the image level is empty. + if (getExtents(target, level).empty()) + { + return angle::Result::Continue; + } + + return mTexture->getCompressedTexImage(context, packState, packBuffer, target, level, pixels); +} + +void Texture::onBindAsImageTexture() +{ + if (!mState.mHasBeenBoundAsImage) + { + mDirtyBits.set(DIRTY_BIT_BOUND_AS_IMAGE); + mState.mHasBeenBoundAsImage = true; + } +} + +void Texture::onBind3DTextureAs2DImage() +{ + if (!mState.mIs3DAndHasBeenBoundAs2DImage) + { + mDirtyBits.set(DIRTY_BIT_BOUND_AS_IMAGE); + mState.mIs3DAndHasBeenBoundAs2DImage = true; + } +} + +} // namespace gl -- cgit v1.2.3