summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/angle/src/libANGLE/Texture.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/Texture.cpp')
-rw-r--r--src/3rdparty/angle/src/libANGLE/Texture.cpp1509
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
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-19 12:55:16 +0000