chromium/third_party/angle/src/libANGLE/Texture.cpp

//
// 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/ContextImpl.h"
#include "libANGLE/renderer/GLImplFactory.h"
#include "libANGLE/renderer/TextureImpl.h"

namespace gl
{

namespace
{
constexpr angle::SubjectIndex kBufferSubjectIndex = …;
static_assert …;
static_assert …;

bool IsPointSampled(const SamplerState &samplerState)
{ … }

size_t GetImageDescIndex(TextureTarget target, size_t level)
{ … }

InitState DetermineInitState(const Context *context, Buffer *unpackBuffer, const uint8_t *pixels)
{ … }
}  // namespace

GLenum ConvertToNearestFilterMode(GLenum filterMode)
{ … }

GLenum ConvertToNearestMipFilterMode(GLenum filterMode)
{ … }

bool IsMipmapSupported(const TextureType &type)
{ … }

SwizzleState::SwizzleState()
    : … { … }

SwizzleState::SwizzleState(GLenum red, GLenum green, GLenum blue, GLenum alpha)
    : … { … }

bool SwizzleState::swizzleRequired() const
{ … }

bool SwizzleState::operator==(const SwizzleState &other) const
{ … }

bool SwizzleState::operator!=(const SwizzleState &other) const
{ … }

TextureState::TextureState(TextureType type)
    : … { … }

TextureState::~TextureState() { … }

bool TextureState::swizzleRequired() const
{ … }

GLuint TextureState::getEffectiveBaseLevel() const
{ … }

GLuint TextureState::getEffectiveMaxLevel() const
{ … }

GLuint TextureState::getMipmapMaxLevel() const
{ … }

bool TextureState::setBaseLevel(GLuint baseLevel)
{ … }

bool TextureState::setMaxLevel(GLuint maxLevel)
{ … }

// 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
{ … }

const ImageDesc &TextureState::getBaseLevelDesc() const
{ … }

const ImageDesc &TextureState::getLevelZeroDesc() const
{ … }

void TextureState::setCrop(const Rectangle &rect)
{ … }

const Rectangle &TextureState::getCrop() const
{ … }

void TextureState::setGenerateMipmapHint(GLenum hint)
{ … }

GLenum TextureState::getGenerateMipmapHint() const
{ … }

SamplerFormat TextureState::computeRequiredSamplerFormat(const SamplerState &samplerState) const
{ … }

bool TextureState::computeSamplerCompleteness(const SamplerState &samplerState,
                                              const State &state) const
{ … }

// 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
{ … }

bool TextureState::computeMipmapCompleteness() const
{ … }

bool TextureState::computeLevelCompleteness(TextureTarget target, size_t level) const
{ … }

TextureTarget TextureState::getBaseImageTarget() const
{ … }

GLuint TextureState::getEnabledLevelCount() const
{ … }

ImageDesc::ImageDesc()
    : … { … }

ImageDesc::ImageDesc(const Extents &size, const Format &format, const InitState initState)
    : … { … }

ImageDesc::ImageDesc(const Extents &size,
                     const Format &format,
                     const GLsizei samples,
                     const bool fixedSampleLocations,
                     const InitState initState)
    : … { … }

GLint ImageDesc::getMemorySize() const
{ … }

const ImageDesc &TextureState::getImageDesc(TextureTarget target, size_t level) const
{ … }

void TextureState::setImageDesc(TextureTarget target, size_t level, const ImageDesc &desc)
{ … }

// 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
{ … }

void TextureState::setImageDescChain(GLuint baseLevel,
                                     GLuint maxLevel,
                                     Extents baseSize,
                                     const Format &format,
                                     InitState initState)
{ … }

void TextureState::setImageDescChainMultisample(Extents baseSize,
                                                const Format &format,
                                                GLsizei samples,
                                                bool fixedSampleLocations,
                                                InitState initState)
{ … }

void TextureState::clearImageDesc(TextureTarget target, size_t level)
{ … }

void TextureState::clearImageDescs()
{ … }

TextureBufferContentsObservers::TextureBufferContentsObservers(Texture *texture) : … { … }

void TextureBufferContentsObservers::enableForBuffer(Buffer *buffer)
{ … }

void TextureBufferContentsObservers::disableForBuffer(Buffer *buffer)
{ … }

Texture::Texture(rx::GLImplFactory *factory, TextureID id, TextureType type)
    : … { … }

void Texture::onDestroy(const Context *context)
{ … }

Texture::~Texture()
{ … }

angle::Result Texture::setLabel(const Context *context, const std::string &label)
{ … }

const std::string &Texture::getLabel() const
{ … }

void Texture::setSwizzleRed(const Context *context, GLenum swizzleRed)
{ … }

GLenum Texture::getSwizzleRed() const
{ … }

void Texture::setSwizzleGreen(const Context *context, GLenum swizzleGreen)
{ … }

GLenum Texture::getSwizzleGreen() const
{ … }

void Texture::setSwizzleBlue(const Context *context, GLenum swizzleBlue)
{ … }

GLenum Texture::getSwizzleBlue() const
{ … }

void Texture::setSwizzleAlpha(const Context *context, GLenum swizzleAlpha)
{ … }

GLenum Texture::getSwizzleAlpha() const
{ … }

void Texture::setMinFilter(const Context *context, GLenum minFilter)
{ … }

GLenum Texture::getMinFilter() const
{ … }

void Texture::setMagFilter(const Context *context, GLenum magFilter)
{ … }

GLenum Texture::getMagFilter() const
{ … }

void Texture::setWrapS(const Context *context, GLenum wrapS)
{ … }

GLenum Texture::getWrapS() const
{ … }

void Texture::setWrapT(const Context *context, GLenum wrapT)
{ … }

GLenum Texture::getWrapT() const
{ … }

void Texture::setWrapR(const Context *context, GLenum wrapR)
{ … }

GLenum Texture::getWrapR() const
{ … }

void Texture::setMaxAnisotropy(const Context *context, float maxAnisotropy)
{ … }

float Texture::getMaxAnisotropy() const
{ … }

void Texture::setMinLod(const Context *context, GLfloat minLod)
{ … }

GLfloat Texture::getMinLod() const
{ … }

void Texture::setMaxLod(const Context *context, GLfloat maxLod)
{ … }

GLfloat Texture::getMaxLod() const
{ … }

void Texture::setCompareMode(const Context *context, GLenum compareMode)
{ … }

GLenum Texture::getCompareMode() const
{ … }

void Texture::setCompareFunc(const Context *context, GLenum compareFunc)
{ … }

GLenum Texture::getCompareFunc() const
{ … }

void Texture::setSRGBDecode(const Context *context, GLenum sRGBDecode)
{ … }

GLenum Texture::getSRGBDecode() const
{ … }

void Texture::setSRGBOverride(const Context *context, GLenum sRGBOverride)
{ … }

GLenum Texture::getSRGBOverride() const
{ … }

const SamplerState &Texture::getSamplerState() const
{ … }

angle::Result Texture::setBaseLevel(const Context *context, GLuint baseLevel)
{ … }

GLuint Texture::getBaseLevel() const
{ … }

void Texture::setMaxLevel(const Context *context, GLuint maxLevel)
{ … }

GLuint Texture::getMaxLevel() const
{ … }

void Texture::setDepthStencilTextureMode(const Context *context, GLenum mode)
{ … }

GLenum Texture::getDepthStencilTextureMode() const
{ … }

bool Texture::getImmutableFormat() const
{ … }

GLuint Texture::getImmutableLevels() const
{ … }

void Texture::setUsage(const Context *context, GLenum usage)
{ … }

GLenum Texture::getUsage() const
{ … }

void Texture::setProtectedContent(Context *context, bool hasProtectedContent)
{ … }

bool Texture::hasProtectedContent() const
{ … }

void Texture::setRenderabilityValidation(Context *context, bool renderabilityValidation)
{ … }

void Texture::setTilingMode(Context *context, GLenum tilingMode)
{ … }

GLenum Texture::getTilingMode() const
{ … }

const TextureState &Texture::getTextureState() const
{ … }

const Extents &Texture::getExtents(TextureTarget target, size_t level) const
{ … }

size_t Texture::getWidth(TextureTarget target, size_t level) const
{ … }

size_t Texture::getHeight(TextureTarget target, size_t level) const
{ … }

size_t Texture::getDepth(TextureTarget target, size_t level) const
{ … }

const Format &Texture::getFormat(TextureTarget target, size_t level) const
{ … }

GLsizei Texture::getSamples(TextureTarget target, size_t level) const
{ … }

bool Texture::getFixedSampleLocations(TextureTarget target, size_t level) const
{ … }

GLuint Texture::getMipmapMaxLevel() const
{ … }

bool Texture::isMipmapComplete() const
{ … }

GLuint Texture::getFoveatedFeatureBits() const
{ … }

void Texture::setFoveatedFeatureBits(const GLuint features)
{ … }

bool Texture::isFoveationEnabled() const
{ … }

GLuint Texture::getSupportedFoveationFeatures() const
{ … }

GLfloat Texture::getMinPixelDensity() const
{ … }

void Texture::setMinPixelDensity(const GLfloat density)
{ … }

void Texture::setFocalPoint(uint32_t layer,
                            uint32_t focalPointIndex,
                            float focalX,
                            float focalY,
                            float gainX,
                            float gainY,
                            float foveaArea)
{ … }

const FocalPoint &Texture::getFocalPoint(uint32_t layer, uint32_t focalPoint) const
{ … }

egl::Surface *Texture::getBoundSurface() const
{ … }

egl::Stream *Texture::getBoundStream() const
{ … }

GLint Texture::getMemorySize() const
{ … }

GLint Texture::getLevelMemorySize(TextureTarget target, GLint level) const
{ … }

void Texture::signalDirtyStorage(InitState initState)
{ … }

void Texture::signalDirtyState(size_t dirtyBit)
{ … }

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)
{ … }

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)
{ … }

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)
{ … }

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)
{ … }

angle::Result Texture::copyImage(Context *context,
                                 TextureTarget target,
                                 GLint level,
                                 const Rectangle &sourceArea,
                                 GLenum internalFormat,
                                 Framebuffer *source)
{ … }

angle::Result Texture::copySubImage(Context *context,
                                    const ImageIndex &index,
                                    const Offset &destOffset,
                                    const Rectangle &sourceArea,
                                    Framebuffer *source)
{ … }

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::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::Result Texture::copyTexture(Context *context,
                                   TextureTarget target,
                                   GLint level,
                                   GLenum internalFormat,
                                   GLenum type,
                                   GLint sourceLevel,
                                   bool unpackFlipY,
                                   bool unpackPremultiplyAlpha,
                                   bool unpackUnmultiplyAlpha,
                                   Texture *source)
{ … }

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)
{ … }

angle::Result Texture::copyCompressedTexture(Context *context, const Texture *source)
{ … }

angle::Result Texture::setStorage(Context *context,
                                  TextureType type,
                                  GLsizei levels,
                                  GLenum internalFormat,
                                  const Extents &size)
{ … }

angle::Result Texture::setImageExternal(Context *context,
                                        TextureTarget target,
                                        GLint level,
                                        GLenum internalFormat,
                                        const Extents &size,
                                        GLenum format,
                                        GLenum type)
{ … }

angle::Result Texture::setStorageMultisample(Context *context,
                                             TextureType type,
                                             GLsizei samplesIn,
                                             GLint internalFormat,
                                             const Extents &size,
                                             bool fixedSampleLocations)
{ … }

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)
{ … }

angle::Result Texture::generateMipmap(Context *context)
{ … }

angle::Result Texture::clearImage(Context *context,
                                  GLint level,
                                  GLenum format,
                                  GLenum type,
                                  const uint8_t *data)
{ … }

angle::Result Texture::clearSubImage(Context *context,
                                     GLint level,
                                     const Box &area,
                                     GLenum format,
                                     GLenum type,
                                     const uint8_t *data)
{ … }

angle::Result Texture::bindTexImageFromSurface(Context *context, egl::Surface *surface)
{ … }

angle::Result Texture::releaseTexImageFromSurface(const Context *context)
{ … }

void Texture::bindStream(egl::Stream *stream)
{ … }

void Texture::releaseStream()
{ … }

angle::Result Texture::acquireImageFromStream(const Context *context,
                                              const egl::Stream::GLTextureDescription &desc)
{ … }

angle::Result Texture::releaseImageFromStream(const Context *context)
{ … }

angle::Result Texture::releaseTexImageInternal(Context *context)
{ … }

angle::Result Texture::setEGLImageTargetImpl(Context *context,
                                             TextureType type,
                                             GLuint levels,
                                             egl::Image *imageTarget)
{ … }

angle::Result Texture::setEGLImageTarget(Context *context,
                                         TextureType type,
                                         egl::Image *imageTarget)
{ … }

angle::Result Texture::setStorageEGLImageTarget(Context *context,
                                                TextureType type,
                                                egl::Image *imageTarget,
                                                const GLint *attrib_list)
{ … }

Extents Texture::getAttachmentSize(const ImageIndex &imageIndex) const
{ … }

Format Texture::getAttachmentFormat(GLenum /*binding*/, const ImageIndex &imageIndex) const
{ … }

GLsizei Texture::getAttachmentSamples(const ImageIndex &imageIndex) const
{ … }

bool Texture::isRenderable(const Context *context,
                           GLenum binding,
                           const ImageIndex &imageIndex) const
{ … }

bool Texture::getAttachmentFixedSampleLocations(const ImageIndex &imageIndex) const
{ … }

void Texture::setBorderColor(const Context *context, const ColorGeneric &color)
{ … }

const ColorGeneric &Texture::getBorderColor() const
{ … }

GLint Texture::getRequiredTextureImageUnits(const Context *context) const
{ … }

void Texture::setCrop(const Rectangle &rect)
{ … }

const Rectangle &Texture::getCrop() const
{ … }

void Texture::setGenerateMipmapHint(GLenum hint)
{ … }

GLenum Texture::getGenerateMipmapHint() const
{ … }

angle::Result Texture::setBuffer(const gl::Context *context,
                                 gl::Buffer *buffer,
                                 GLenum internalFormat)
{ … }

angle::Result Texture::setBufferRange(const gl::Context *context,
                                      gl::Buffer *buffer,
                                      GLenum internalFormat,
                                      GLintptr offset,
                                      GLsizeiptr size)
{ … }

const OffsetBindingPointer<Buffer> &Texture::getBuffer() const
{ … }

void Texture::onAttach(const Context *context, rx::UniqueSerial framebufferSerial)
{ … }

void Texture::onDetach(const Context *context, rx::UniqueSerial framebufferSerial)
{ … }

GLuint Texture::getId() const
{ … }

GLuint Texture::getNativeID() const
{ … }

angle::Result Texture::syncState(const Context *context, Command source)
{ … }

rx::FramebufferAttachmentObjectImpl *Texture::getAttachmentImpl() const
{ … }

bool Texture::isSamplerComplete(const Context *context, const Sampler *optionalSampler)
{ … }

// CopyImageSubData requires that we ignore format-based completeness rules
bool Texture::isSamplerCompleteForCopyImage(const Context *context,
                                            const Sampler *optionalSampler) const
{ … }

Texture::SamplerCompletenessCache::SamplerCompletenessCache()
    : … { … }

void Texture::invalidateCompletenessCache() const
{ … }

angle::Result Texture::ensureInitialized(const Context *context)
{ … }

InitState Texture::initState(GLenum /*binding*/, const ImageIndex &imageIndex) const
{ … }

void Texture::setInitState(GLenum binding, const ImageIndex &imageIndex, InitState initState)
{ … }

void Texture::setInitState(InitState initState)
{ … }

bool Texture::doesSubImageNeedInit(const Context *context,
                                   const ImageIndex &imageIndex,
                                   const Box &area) const
{ … }

angle::Result Texture::ensureSubImageInitialized(const Context *context,
                                                 const ImageIndex &imageIndex,
                                                 const Box &area)
{ … }

angle::Result Texture::handleMipmapGenerationHint(Context *context, int level)
{ … }

void Texture::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{ … }

void Texture::onBufferContentsChange()
{ … }

void Texture::onBindToMSRTTFramebuffer()
{ … }

GLenum Texture::getImplementationColorReadFormat(const Context *context) const
{ … }

GLenum Texture::getImplementationColorReadType(const Context *context) const
{ … }

angle::Result Texture::getTexImage(const Context *context,
                                   const PixelPackState &packState,
                                   Buffer *packBuffer,
                                   TextureTarget target,
                                   GLint level,
                                   GLenum format,
                                   GLenum type,
                                   void *pixels)
{ … }

angle::Result Texture::getCompressedTexImage(const Context *context,
                                             const PixelPackState &packState,
                                             Buffer *packBuffer,
                                             TextureTarget target,
                                             GLint level,
                                             void *pixels)
{ … }

void Texture::onBindAsImageTexture()
{ … }

}  // namespace gl