diff options
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/Texture.cpp')
| -rw-r--r-- | src/3rdparty/angle/src/libANGLE/Texture.cpp | 502 |
1 files changed, 407 insertions, 95 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/Texture.cpp b/src/3rdparty/angle/src/libANGLE/Texture.cpp index cd4584f694..5ef6762d3d 100644 --- a/src/3rdparty/angle/src/libANGLE/Texture.cpp +++ b/src/3rdparty/angle/src/libANGLE/Texture.cpp @@ -7,14 +7,15 @@ // Texture.cpp: Implements the gl::Texture class. [OpenGL ES 2.0.24] section 3.7 page 63. #include "libANGLE/Texture.h" -#include "libANGLE/Data.h" -#include "libANGLE/formatutils.h" - -#include "libANGLE/Config.h" -#include "libANGLE/Surface.h" #include "common/mathutil.h" #include "common/utilities.h" +#include "libANGLE/Config.h" +#include "libANGLE/Context.h" +#include "libANGLE/Data.h" +#include "libANGLE/Image.h" +#include "libANGLE/Surface.h" +#include "libANGLE/formatutils.h" namespace gl { @@ -46,14 +47,11 @@ static size_t GetImageDescIndex(GLenum target, size_t level) return IsCubeMapTextureTarget(target) ? ((level * 6) + CubeMapTextureTargetToLayerIndex(target)) : level; } -unsigned int Texture::mCurrentTextureSerial = 1; - Texture::Texture(rx::TextureImpl *impl, GLuint id, GLenum target) - : RefCountObject(id), + : egl::ImageSibling(id), mTexture(impl), - mTextureSerial(issueTextureSerial()), - mUsage(GL_NONE), - mImmutableLevelCount(0), + mLabel(), + mTextureState(), mTarget(target), mImageDescs(IMPLEMENTATION_MAX_TEXTURE_LEVELS * (target == GL_TEXTURE_CUBE_MAP ? 6 : 1)), mCompletenessCache(), @@ -71,20 +69,210 @@ Texture::~Texture() SafeDelete(mTexture); } +void Texture::setLabel(const std::string &label) +{ + mLabel = label; +} + +const std::string &Texture::getLabel() const +{ + return mLabel; +} + GLenum Texture::getTarget() const { return mTarget; } +void Texture::setSwizzleRed(GLenum swizzleRed) +{ + mTextureState.swizzleRed = swizzleRed; +} + +GLenum Texture::getSwizzleRed() const +{ + return mTextureState.swizzleRed; +} + +void Texture::setSwizzleGreen(GLenum swizzleGreen) +{ + mTextureState.swizzleGreen = swizzleGreen; +} + +GLenum Texture::getSwizzleGreen() const +{ + return mTextureState.swizzleGreen; +} + +void Texture::setSwizzleBlue(GLenum swizzleBlue) +{ + mTextureState.swizzleBlue = swizzleBlue; +} + +GLenum Texture::getSwizzleBlue() const +{ + return mTextureState.swizzleBlue; +} + +void Texture::setSwizzleAlpha(GLenum swizzleAlpha) +{ + mTextureState.swizzleAlpha = swizzleAlpha; +} + +GLenum Texture::getSwizzleAlpha() const +{ + return mTextureState.swizzleAlpha; +} + +void Texture::setMinFilter(GLenum minFilter) +{ + mTextureState.samplerState.minFilter = minFilter; +} + +GLenum Texture::getMinFilter() const +{ + return mTextureState.samplerState.minFilter; +} + +void Texture::setMagFilter(GLenum magFilter) +{ + mTextureState.samplerState.magFilter = magFilter; +} + +GLenum Texture::getMagFilter() const +{ + return mTextureState.samplerState.magFilter; +} + +void Texture::setWrapS(GLenum wrapS) +{ + mTextureState.samplerState.wrapS = wrapS; +} + +GLenum Texture::getWrapS() const +{ + return mTextureState.samplerState.wrapS; +} + +void Texture::setWrapT(GLenum wrapT) +{ + mTextureState.samplerState.wrapT = wrapT; +} + +GLenum Texture::getWrapT() const +{ + return mTextureState.samplerState.wrapT; +} + +void Texture::setWrapR(GLenum wrapR) +{ + mTextureState.samplerState.wrapR = wrapR; +} + +GLenum Texture::getWrapR() const +{ + return mTextureState.samplerState.wrapR; +} + +void Texture::setMaxAnisotropy(float maxAnisotropy) +{ + mTextureState.samplerState.maxAnisotropy = maxAnisotropy; +} + +float Texture::getMaxAnisotropy() const +{ + return mTextureState.samplerState.maxAnisotropy; +} + +void Texture::setMinLod(GLfloat minLod) +{ + mTextureState.samplerState.minLod = minLod; +} + +GLfloat Texture::getMinLod() const +{ + return mTextureState.samplerState.minLod; +} + +void Texture::setMaxLod(GLfloat maxLod) +{ + mTextureState.samplerState.maxLod = maxLod; +} + +GLfloat Texture::getMaxLod() const +{ + return mTextureState.samplerState.maxLod; +} + +void Texture::setCompareMode(GLenum compareMode) +{ + mTextureState.samplerState.compareMode = compareMode; +} + +GLenum Texture::getCompareMode() const +{ + return mTextureState.samplerState.compareMode; +} + +void Texture::setCompareFunc(GLenum compareFunc) +{ + mTextureState.samplerState.compareFunc = compareFunc; +} + +GLenum Texture::getCompareFunc() const +{ + return mTextureState.samplerState.compareFunc; +} + +const SamplerState &Texture::getSamplerState() const +{ + return mTextureState.samplerState; +} + +void Texture::setBaseLevel(GLuint baseLevel) +{ + mTextureState.baseLevel = baseLevel; +} + +GLuint Texture::getBaseLevel() const +{ + return mTextureState.baseLevel; +} + +void Texture::setMaxLevel(GLuint maxLevel) +{ + mTextureState.maxLevel = maxLevel; +} + +GLuint Texture::getMaxLevel() const +{ + return mTextureState.maxLevel; +} + +bool Texture::getImmutableFormat() const +{ + return mTextureState.immutableFormat; +} + +GLuint Texture::getImmutableLevels() const +{ + return mTextureState.immutableLevels; +} + void Texture::setUsage(GLenum usage) { - mUsage = usage; + mTextureState.usage = usage; getImplementation()->setUsage(usage); } GLenum Texture::getUsage() const { - return mUsage; + return mTextureState.usage; +} + +const TextureState &Texture::getTextureState() const +{ + return mTextureState; } size_t Texture::getWidth(GLenum target, size_t level) const @@ -113,7 +301,7 @@ GLenum Texture::getInternalFormat(GLenum target, size_t level) const bool Texture::isSamplerComplete(const SamplerState &samplerState, const Data &data) const { - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), samplerState.baseLevel); + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), mTextureState.baseLevel); const TextureCaps &textureCaps = data.textureCaps->get(baseImageDesc.internalFormat); if (!mCompletenessCache.cacheValid || mCompletenessCache.samplerState != samplerState || @@ -131,6 +319,11 @@ bool Texture::isSamplerComplete(const SamplerState &samplerState, const Data &da return mCompletenessCache.samplerComplete; } +bool Texture::isMipmapComplete() const +{ + return computeMipmapCompleteness(); +} + // Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81. bool Texture::isCubeComplete() const { @@ -156,76 +349,122 @@ bool Texture::isCubeComplete() const return true; } -unsigned int Texture::getTextureSerial() const +size_t Texture::getMipCompleteLevels() const { - return mTextureSerial; + 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; + } } -unsigned int Texture::issueTextureSerial() +egl::Surface *Texture::getBoundSurface() const { - return mCurrentTextureSerial++; + return mBoundSurface; } -bool Texture::isImmutable() const +Error Texture::setImage(Context *context, + GLenum target, + size_t level, + GLenum internalFormat, + const Extents &size, + GLenum format, + GLenum type, + const uint8_t *pixels) { - return (mImmutableLevelCount > 0); -} + ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); -int Texture::immutableLevelCount() -{ - return mImmutableLevelCount; -} + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + releaseTexImageInternal(); + orphanImages(); -Error Texture::setImage(GLenum target, size_t level, GLenum internalFormat, const Extents &size, GLenum format, GLenum type, - const PixelUnpackState &unpack, const uint8_t *pixels) -{ - ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + // Hack: allow nullptr for testing + if (context != nullptr) + { + // Sync the unpack state + context->syncRendererState(context->getState().unpackStateBitMask()); + } + 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; } - releaseTexImage(); - setImageDesc(target, level, ImageDesc(size, GetSizedInternalFormat(internalFormat, type))); return Error(GL_NO_ERROR); } -Error Texture::setSubImage(GLenum target, size_t level, const Box &area, GLenum format, GLenum type, - const PixelUnpackState &unpack, const uint8_t *pixels) +Error Texture::setSubImage(Context *context, + GLenum target, + size_t level, + const Box &area, + GLenum format, + GLenum type, + const uint8_t *pixels) { ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + // Sync the unpack state + context->syncRendererState(context->getState().unpackStateBitMask()); + + const PixelUnpackState &unpack = context->getState().getUnpackState(); return mTexture->setSubImage(target, level, area, format, type, unpack, pixels); } -Error Texture::setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const Extents &size, - const PixelUnpackState &unpack, const uint8_t *pixels) +Error Texture::setCompressedImage(Context *context, + GLenum target, + size_t level, + GLenum internalFormat, + const Extents &size, + size_t imageSize, + const uint8_t *pixels) { ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - Error error = mTexture->setCompressedImage(target, level, internalFormat, size, unpack, pixels); + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + releaseTexImageInternal(); + orphanImages(); + + // 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; } - releaseTexImage(); - setImageDesc(target, level, ImageDesc(size, GetSizedInternalFormat(internalFormat, GL_UNSIGNED_BYTE))); return Error(GL_NO_ERROR); } -Error Texture::setCompressedSubImage(GLenum target, size_t level, const Box &area, GLenum format, - const PixelUnpackState &unpack, const uint8_t *pixels) +Error Texture::setCompressedSubImage(Context *context, + GLenum target, + size_t level, + const Box &area, + GLenum format, + size_t imageSize, + const uint8_t *pixels) { ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); - return mTexture->setCompressedSubImage(target, level, area, format, unpack, pixels); + // Sync the unpack state + context->syncRendererState(context->getState().unpackStateBitMask()); + + const PixelUnpackState &unpack = context->getState().getUnpackState(); + return mTexture->setCompressedSubImage(target, level, area, format, unpack, imageSize, pixels); } Error Texture::copyImage(GLenum target, size_t level, const Rectangle &sourceArea, GLenum internalFormat, @@ -233,14 +472,16 @@ Error Texture::copyImage(GLenum target, size_t level, const Rectangle &sourceAre { ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target))); + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + releaseTexImageInternal(); + orphanImages(); + Error error = mTexture->copyImage(target, level, sourceArea, internalFormat, source); if (error.isError()) { return error; } - releaseTexImage(); - setImageDesc(target, level, ImageDesc(Extents(sourceArea.width, sourceArea.height, 1), GetSizedInternalFormat(internalFormat, GL_UNSIGNED_BYTE))); @@ -259,32 +500,42 @@ Error Texture::setStorage(GLenum target, size_t levels, GLenum internalFormat, c { ASSERT(target == mTarget); + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + releaseTexImageInternal(); + orphanImages(); + Error error = mTexture->setStorage(target, levels, internalFormat, size); if (error.isError()) { return error; } - releaseTexImage(); - - mImmutableLevelCount = levels; + mTextureState.immutableFormat = true; + mTextureState.immutableLevels = static_cast<GLuint>(levels); clearImageDescs(); setImageDescChain(levels, size, internalFormat); return Error(GL_NO_ERROR); } - Error Texture::generateMipmaps() { - Error error = mTexture->generateMipmaps(); + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + releaseTexImageInternal(); + + // EGL_KHR_gl_image states that images are only orphaned when generating mipmaps if the texture + // is not mip complete. + if (!isMipmapComplete()) + { + orphanImages(); + } + + Error error = mTexture->generateMipmaps(mTextureState); if (error.isError()) { return error; } - releaseTexImage(); - 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); @@ -294,16 +545,17 @@ Error Texture::generateMipmaps() void Texture::setImageDescChain(size_t levels, Extents baseSize, GLenum sizedInternalFormat) { - for (size_t level = 0; level < levels; level++) + for (int level = 0; level < static_cast<int>(levels); level++) { - Extents levelSize(std::max<size_t>(baseSize.width >> level, 1), - std::max<size_t>(baseSize.height >> level, 1), - (mTarget == GL_TEXTURE_2D_ARRAY) ? baseSize.depth : std::max<size_t>(baseSize.depth >> level, 1)); + 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); if (mTarget == GL_TEXTURE_CUBE_MAP) { - for (size_t face = FirstCubeMapTextureTarget; face <= LastCubeMapTextureTarget; face++) + for (GLenum face = FirstCubeMapTextureTarget; face <= LastCubeMapTextureTarget; face++) { setImageDesc(face, level, levelInfo); } @@ -316,7 +568,7 @@ void Texture::setImageDescChain(size_t levels, Extents baseSize, GLenum sizedInt } Texture::ImageDesc::ImageDesc() - : size(0, 0, 0), internalFormat(GL_NONE) + : ImageDesc(Extents(0, 0, 0), GL_NONE) { } @@ -355,11 +607,15 @@ void Texture::clearImageDescs() mCompletenessCache.cacheValid = false; } -void Texture::bindTexImage(egl::Surface *surface) +void Texture::bindTexImageFromSurface(egl::Surface *surface) { ASSERT(surface); - releaseTexImage(); + if (mBoundSurface) + { + releaseTexImageFromSurface(); + } + mTexture->bindTexImage(surface); mBoundSurface = surface; @@ -370,40 +626,65 @@ void Texture::bindTexImage(egl::Surface *surface) setImageDesc(mTarget, 0, desc); } -void Texture::releaseTexImage() +void Texture::releaseTexImageFromSurface() +{ + ASSERT(mBoundSurface); + mBoundSurface = nullptr; + mTexture->releaseTexImage(); + + // Erase the image info for level 0 + ASSERT(mTarget == GL_TEXTURE_2D); + clearImageDesc(mTarget, 0); +} + +void Texture::releaseTexImageInternal() { if (mBoundSurface) { - mBoundSurface = NULL; - mTexture->releaseTexImage(); + // Notify the surface + mBoundSurface->releaseTexImageFromTexture(); - // Erase the image info for level 0 - ASSERT(mTarget == GL_TEXTURE_2D); - clearImageDesc(mTarget, 0); + // Then, call the same method as from the surface + releaseTexImageFromSurface(); } } -GLenum Texture::getBaseImageTarget() const +Error Texture::setEGLImageTarget(GLenum target, egl::Image *imageTarget) { - return mTarget == GL_TEXTURE_CUBE_MAP ? FirstCubeMapTextureTarget : mTarget; -} + ASSERT(target == mTarget); + ASSERT(target == GL_TEXTURE_2D); -size_t Texture::getExpectedMipLevels() const -{ - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), 0); - if (mTarget == GL_TEXTURE_3D) - { - return log2(std::max(std::max(baseImageDesc.size.width, baseImageDesc.size.height), baseImageDesc.size.depth)) + 1; - } - else + // Release from previous calls to eglBindTexImage, to avoid calling the Impl after + releaseTexImageInternal(); + orphanImages(); + + Error error = mTexture->setEGLImageTarget(target, imageTarget); + if (error.isError()) { - return log2(std::max(baseImageDesc.size.width, baseImageDesc.size.height)) + 1; + return error; } + + setTargetImage(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))); + + return Error(GL_NO_ERROR); +} + +GLenum Texture::getBaseImageTarget() const +{ + return mTarget == GL_TEXTURE_CUBE_MAP ? FirstCubeMapTextureTarget : mTarget; } bool Texture::computeSamplerCompleteness(const SamplerState &samplerState, const Data &data) const { - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), samplerState.baseLevel); + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), mTextureState.baseLevel); if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 || baseImageDesc.size.depth == 0) { return false; @@ -440,7 +721,7 @@ bool Texture::computeSamplerCompleteness(const SamplerState &samplerState, const } } - if (!computeMipmapCompleteness(samplerState)) + if (!computeMipmapCompleteness()) { return false; } @@ -474,19 +755,19 @@ bool Texture::computeSamplerCompleteness(const SamplerState &samplerState, const return true; } -bool Texture::computeMipmapCompleteness(const gl::SamplerState &samplerState) const +bool Texture::computeMipmapCompleteness() const { - size_t expectedMipLevels = getExpectedMipLevels(); + size_t expectedMipLevels = getMipCompleteLevels(); - size_t maxLevel = std::min<size_t>(expectedMipLevels, samplerState.maxLevel + 1); + size_t maxLevel = std::min<size_t>(expectedMipLevels, mTextureState.maxLevel + 1); - for (size_t level = samplerState.baseLevel; level < maxLevel; level++) + 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, samplerState)) + if (!computeLevelCompleteness(face, level)) { return false; } @@ -494,7 +775,7 @@ bool Texture::computeMipmapCompleteness(const gl::SamplerState &samplerState) co } else { - if (!computeLevelCompleteness(mTarget, level, samplerState)) + if (!computeLevelCompleteness(mTarget, level)) { return false; } @@ -504,47 +785,48 @@ bool Texture::computeMipmapCompleteness(const gl::SamplerState &samplerState) co return true; } - -bool Texture::computeLevelCompleteness(GLenum target, size_t level, const gl::SamplerState &samplerState) const +bool Texture::computeLevelCompleteness(GLenum target, size_t level) const { ASSERT(level < IMPLEMENTATION_MAX_TEXTURE_LEVELS); - if (isImmutable()) + if (mTextureState.immutableFormat) { return true; } - const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), samplerState.baseLevel); + const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), mTextureState.baseLevel); if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 || baseImageDesc.size.depth == 0) { return false; } - // The base image level is complete if the width and height are positive - if (level == 0) + const ImageDesc &levelImageDesc = getImageDesc(target, level); + if (levelImageDesc.size.width == 0 || levelImageDesc.size.height == 0 || + levelImageDesc.size.depth == 0) { - return true; + return false; } - const ImageDesc &levelImageDesc = getImageDesc(target, level); if (levelImageDesc.internalFormat != baseImageDesc.internalFormat) { return false; } - if (levelImageDesc.size.width != std::max(1, baseImageDesc.size.width >> level)) + ASSERT(level >= mTextureState.baseLevel); + const size_t relativeLevel = level - mTextureState.baseLevel; + if (levelImageDesc.size.width != std::max(1, baseImageDesc.size.width >> relativeLevel)) { return false; } - if (levelImageDesc.size.height != std::max(1, baseImageDesc.size.height >> level)) + 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 >> level)) + if (levelImageDesc.size.depth != std::max(1, baseImageDesc.size.depth >> relativeLevel)) { return false; } @@ -570,4 +852,34 @@ Texture::SamplerCompletenessCache::SamplerCompletenessCache() { } +Extents Texture::getAttachmentSize(const gl::FramebufferAttachment::Target &target) const +{ + return getImageDesc(target.textureIndex().type, target.textureIndex().mipIndex).size; +} + +GLenum Texture::getAttachmentInternalFormat(const gl::FramebufferAttachment::Target &target) const +{ + return getInternalFormat(target.textureIndex().type, target.textureIndex().mipIndex); +} + +GLsizei Texture::getAttachmentSamples(const gl::FramebufferAttachment::Target &/*target*/) const +{ + // Multisample textures not currently supported + return 0; +} + +void Texture::onAttach() +{ + addRef(); +} + +void Texture::onDetach() +{ + release(); +} + +GLuint Texture::getId() const +{ + return id(); +} } |