#include <kis_texture_tile.h>

Public Member Functions
int	bindToActiveTexture (bool blockMipmapRegeneration)

QRectF	imageRectInTexturePixels (const QRect &imageRect) const

	KisTextureTile (const QRect &imageRect, const KisGLTexturesInfo texturesInfo, const QByteArray &fillData, KisOpenGL::FilterMode mode, KisOpenGLBufferCircularStorage bufferStorage, int numMipmapLevels, QOpenGLFunctions *f)

void	setBufferStorage (KisOpenGLBufferCircularStorage *bufferStorage)

void	setNumMipmapLevels (int num)

QRect	textureRectInImagePixels ()

QRect	tileRectInImagePixels ()

QRectF	tileRectInTexturePixels ()

void	update (const KisTextureTileUpdateInfo &updateInfo, bool blockMipmapRegeneration)

	~KisTextureTile ()

Private Member Functions
void	regenerateMipmap ()

void	restoreTextureParameters ()

void	setNeedsMipmapRegeneration ()

void	setPreparedLodPlane (int lod)

void	setTextureParameters ()

Private Attributes
QOpenGLFunctions *	f

KisOpenGLBufferCircularStorage *	m_bufferStorage

KisOpenGL::FilterMode	m_filter

bool	m_mipmapHasBeenAllocated = false

bool	m_needsMipmapRegeneration

int	m_numMipmapLevels

int	m_preparedLodPlane

GLuint	m_textureId

QRect	m_textureRectInImagePixels

const KisGLTexturesInfo *	m_texturesInfo

QRect	m_tileRectInImagePixels

QRectF	m_tileRectInTexturePixels

Detailed Description

Definition at line 40 of file kis_texture_tile.h.

Constructor & Destructor Documentation

◆ KisTextureTile()

KisTextureTile::KisTextureTile	(	const QRect &	imageRect,
		const KisGLTexturesInfo *	texturesInfo,
		const QByteArray &	fillData,
		KisOpenGL::FilterMode	mode,
		KisOpenGLBufferCircularStorage *	bufferStorage,
		int	numMipmapLevels,
		QOpenGLFunctions *	f )

Definition at line 72 of file kis_texture_tile.cpp.

    : m_textureId(0)
    , m_tileRectInImagePixels(imageRect)
    , m_filter(filter)
    , m_texturesInfo(texturesInfo)
    , m_needsMipmapRegeneration(false)
    , m_preparedLodPlane(0)
    , m_numMipmapLevels(numMipmapLevels)
    , f(fcn)
    , m_bufferStorage(bufferStorage)
{
    const GLvoid *fd = fillData.constData();
 
    m_textureRectInImagePixels =
            kisGrowRect(m_tileRectInImagePixels, texturesInfo->border);
 
    m_tileRectInTexturePixels = relativeRect(m_textureRectInImagePixels,
                                             m_tileRectInImagePixels,
                                             m_texturesInfo);
 
    f->glGenTextures(1, &m_textureId);
    f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
    setTextureParameters();
 
    KisOpenGLBufferCircularStorage::BufferBinder binder(
        m_bufferStorage, &fd, fillData.size());
 
    f->glTexImage2D(GL_TEXTURE_2D, 0,
                 m_texturesInfo->internalFormat,
                 m_texturesInfo->width,
                 m_texturesInfo->height, 0,
                 m_texturesInfo->format,
                 m_texturesInfo->type, fd);
 
    restoreTextureParameters();
 
    setNeedsMipmapRegeneration();
}

References KisGLTexturesInfo::border, f, fillData(), KisGLTexturesInfo::format, KisGLTexturesInfo::height, KisGLTexturesInfo::internalFormat, kisGrowRect(), m_bufferStorage, m_textureId, m_textureRectInImagePixels, m_texturesInfo, m_tileRectInImagePixels, m_tileRectInTexturePixels, relativeRect(), restoreTextureParameters(), setNeedsMipmapRegeneration(), setTextureParameters(), KisOpenGLBufferCircularStorage::size(), KisGLTexturesInfo::type, and KisGLTexturesInfo::width.

◆ ~KisTextureTile()

KisTextureTile::~KisTextureTile ( )

Definition at line 115 of file kis_texture_tile.cpp.

{
    f->glDeleteTextures(1, &m_textureId);
}

References f, and m_textureId.

Member Function Documentation

◆ bindToActiveTexture()

int KisTextureTile::bindToActiveTexture ( bool blockMipmapRegeneration )

Binds the tile's texture to the current GL_TEXTURE_2D binding point, regenerates the mipmap if needed and returns the levelOfDetail that should be used for painting

Definition at line 120 of file kis_texture_tile.cpp.

{
    f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
    if (m_needsMipmapRegeneration && !blockMipmapRegeneration) {
        regenerateMipmap();
        setPreparedLodPlane(0);
    }
 
    return m_preparedLodPlane;
}

References f, m_needsMipmapRegeneration, m_preparedLodPlane, m_textureId, regenerateMipmap(), and setPreparedLodPlane().

◆ imageRectInTexturePixels()

QRectF KisTextureTile::imageRectInTexturePixels ( const QRect & imageRect ) const

Definition at line 384 of file kis_texture_tile.cpp.

{
    return relativeRect(m_textureRectInImagePixels,
                        imageRect,
                        m_texturesInfo);
 
}

References m_textureRectInImagePixels, m_texturesInfo, and relativeRect().

◆ regenerateMipmap()

void KisTextureTile::regenerateMipmap ( )

private

Definition at line 147 of file kis_texture_tile.cpp.

{
    f->glGenerateMipmap(GL_TEXTURE_2D);
    m_mipmapHasBeenAllocated = true;
    m_needsMipmapRegeneration = false;
}

References f, m_mipmapHasBeenAllocated, and m_needsMipmapRegeneration.

◆ restoreTextureParameters()

void KisTextureTile::restoreTextureParameters ( )

inlineprivate

Definition at line 51 of file kis_texture_tile.cpp.

{
    // QPainter::drawText relies on this.
    // Ref: https://bugreports.qt.io/browse/QTBUG-65496
    f->glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
}

References f.

◆ setBufferStorage()

void KisTextureTile::setBufferStorage ( KisOpenGLBufferCircularStorage * bufferStorage )

inline

Definition at line 48 of file kis_texture_tile.h.

                                                                         {
        m_bufferStorage = bufferStorage;
    }

References m_bufferStorage.

◆ setNeedsMipmapRegeneration()

void KisTextureTile::setNeedsMipmapRegeneration ( )

private

Definition at line 132 of file kis_texture_tile.cpp.

{
    if (m_filter == KisOpenGL::TrilinearFilterMode ||
        m_filter == KisOpenGL::HighQualityFiltering) {
 
        m_needsMipmapRegeneration = true;
    }
}

References KisOpenGL::HighQualityFiltering, m_filter, m_needsMipmapRegeneration, and KisOpenGL::TrilinearFilterMode.

◆ setNumMipmapLevels()

void KisTextureTile::setNumMipmapLevels ( int num )

inline

Definition at line 52 of file kis_texture_tile.h.

                                     {
        m_numMipmapLevels = num;
    }

References m_numMipmapLevels.

◆ setPreparedLodPlane()

void KisTextureTile::setPreparedLodPlane ( int lod )

private

Definition at line 141 of file kis_texture_tile.cpp.

{
    m_preparedLodPlane = lod;
    m_needsMipmapRegeneration = false;
}

References m_needsMipmapRegeneration, and m_preparedLodPlane.

◆ setTextureParameters()

void KisTextureTile::setTextureParameters ( )

inlineprivate

Definition at line 26 of file kis_texture_tile.cpp.

{
 
    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);
    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, m_numMipmapLevels);
    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, m_numMipmapLevels);
 
    if ((m_texturesInfo->internalFormat == GL_RGBA8 && m_texturesInfo->format == GL_RGBA)
#ifndef QT_OPENGL_ES_2
        || (m_texturesInfo->internalFormat == GL_RGBA16 && m_texturesInfo->format == GL_RGBA)
#endif
        || (m_texturesInfo->internalFormat == GL_RGBA16_EXT && m_texturesInfo->format == GL_RGBA)
    ) {
        // If image format is RGBA8, swap the red and blue channels for the proper color
        // This is for OpenGL ES support and only used if lacking GL_EXT_texture_format_BGRA8888
        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
    }
 
    f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}

References f, KisGLTexturesInfo::format, GL_CLAMP_TO_EDGE, GL_RGBA16_EXT, KisGLTexturesInfo::internalFormat, m_numMipmapLevels, and m_texturesInfo.

◆ textureRectInImagePixels()

QRect KisTextureTile::textureRectInImagePixels ( )

inline

Definition at line 62 of file kis_texture_tile.h.

                                            {
        return m_textureRectInImagePixels;
    }

References m_textureRectInImagePixels.

◆ tileRectInImagePixels()

QRect KisTextureTile::tileRectInImagePixels ( )

inline

Definition at line 58 of file kis_texture_tile.h.

                                         {
        return m_tileRectInImagePixels;
    }

References m_tileRectInImagePixels.

◆ tileRectInTexturePixels()

QRectF KisTextureTile::tileRectInTexturePixels ( )

inline

Definition at line 66 of file kis_texture_tile.h.

                                            {
        return m_tileRectInTexturePixels;
    }

References m_tileRectInTexturePixels.

◆ update()

void KisTextureTile::update	(	const KisTextureTileUpdateInfo &	updateInfo,
		bool	blockMipmapRegeneration )

In some special case, when the Lod0 stroke is cancelled the following situation is possible:

1) The stroke is cancelled, Lod0 update is issued by the image. LodN level of the openGL times is still dirty.

2) [here, ideally, the canvas should be re-rendered, so that the mipmap would be regenerated in bindToActiveTexture() call, by in some cases (if you cancel and paint to quickly), that doesn't have time to happen]

3) The new LodN stroke issues a partial update of a LodN plane of the tile. But the plane is still dirty! We update a part of it, but we cannot regenerate the mipmap anymore, because the Lod0 level is not known yet!

To avoid this issue, we should regenerate the dirty mipmap before doing anything with the low-resolution plane.

Another case is when the user has Bilinear or Nearest Neighbour filtering selected and tries to use LoD functionality in animation. glTexSubImage2D() and textureLod() are defined only when all the planes were explicitly initialized with glTexImage2D(), which doesn't happen in case of bilinear- or nn-filtering. In this case !m_mipmapHasBeenAllocated condition comes in.

When in a mode that doesn't use mipmaps we should just switch back onto lod0 plane instead of requesting full mipmap regeneration.

Definition at line 154 of file kis_texture_tile.cpp.

{
    f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
    setTextureParameters();
 
    const int patchLevelOfDetail = updateInfo.patchLevelOfDetail();
    const QSize patchSize = updateInfo.realPatchSize();
    const QPoint patchOffset = updateInfo.realPatchOffset();
 
    if (!blockMipmapRegeneration &&
        patchLevelOfDetail > 0 &&
        (m_needsMipmapRegeneration &&
         !updateInfo.isEntireTileUpdated())
            || !m_mipmapHasBeenAllocated) {
 
        regenerateMipmap();
    }
 
    /*
     * To avoid unsightly seams in wraparound mode, we extend the tile at the
     * edges by just repeating the top/left/right/bottom row/column until the
     * end of the texture. For that, we shuffle the data into a buffer, then
     * pass that to the PBO. Previously, this code used to allocate up to four
     * additional, single-pixel thick (and sometimes zero-pixel long) PBOs and
     * hammer out the extensions through multiple calls to glTexSubImage2D, but
     * that caused very long stalls on Android. If you are in the future and
     * for some reason need to revert that, also update KisOpenGLImageTextures
     * to properly account for these extra PBOs being used, since it assumes
     * each tile only grabs one PBO from the circular buffer storage.
     */
    QSize tileSize = updateInfo.realTileSize();
    int pixelSize = updateInfo.pixelSize();
    int centerWidth = patchSize.width();
    int centerHeight = patchSize.height();
 
    int topHeight;
    if (updateInfo.isTopmost()) {
        topHeight = patchOffset.y();
    } else {
        topHeight = 0;
    }
 
    int leftWidth;
    if (updateInfo.isLeftmost()) {
        leftWidth = patchOffset.x();
    } else {
        leftWidth = 0;
    }
 
    int rightWidth;
    if (updateInfo.isRightmost()) {
        rightWidth = tileSize.width() - patchOffset.x() - centerWidth;
    } else {
        rightWidth = 0;
    }
 
    int bottomHeight;
    if (updateInfo.isBottommost()) {
        bottomHeight = tileSize.height() - patchOffset.y() - centerHeight;
    } else {
        bottomHeight = 0;
    }
 
    if (topHeight > 0 || leftWidth > 0 || rightWidth > 0 || bottomHeight > 0) {
        int bufWidth = leftWidth + centerWidth + rightWidth;
        int bufHeight = topHeight + centerHeight + bottomHeight;
 
        int centerStride = centerWidth * pixelSize;
        int leftStride = leftWidth * pixelSize;
        int rightStride = rightWidth * pixelSize;
        int bufStride = bufWidth * pixelSize;
 
        QByteArray buf(bufStride * bufHeight, 0);
        quint8 *bufData = reinterpret_cast<quint8 *>(buf.data());
        const quint8 *patchData = updateInfo.data();
 
        if (topHeight > 0) {
            const quint8 *topSrcPtr = patchData;
            quint8 *topDstPtr = bufData + leftStride;
            for (int y = 0; y < topHeight; ++y) {
                memcpy(topDstPtr, topSrcPtr, centerStride);
                topDstPtr += bufStride;
            }
        }
 
        if (leftWidth > 0) {
            int leftDstSkip = centerStride + rightStride;
            const quint8 *leftSrcPtr = patchData;
            quint8 *leftDstPtr = bufData + (topHeight * bufStride);
            for (int y = 0; y < centerHeight; ++y) {
                for (int x = 0; x < leftWidth; ++x) {
                    memcpy(leftDstPtr, leftSrcPtr, pixelSize);
                    leftDstPtr += pixelSize;
                }
                leftSrcPtr += centerStride;
                leftDstPtr += leftDstSkip;
            }
        }
 
        {
            const quint8 *centerSrcPtr = patchData;
            quint8 *centerDstPtr = bufData + (topHeight * bufStride) + leftStride;
            for (int y = 0; y < centerHeight; ++y) {
                memcpy(centerDstPtr, centerSrcPtr, centerStride);
                centerSrcPtr += centerStride;
                centerDstPtr += bufStride;
            }
        }
 
        if (rightWidth > 0) {
            int rightDstSkip = leftStride + centerStride;
            const quint8 *rightSrcPtr = patchData + (centerStride - pixelSize);
            quint8 *rightDstPtr = bufData + (topHeight * bufStride) + rightDstSkip;
            for (int y = 0; y < centerHeight; ++y) {
                for (int x = 0; x < rightWidth; ++x) {
                    memcpy(rightDstPtr, rightSrcPtr, pixelSize);
                    rightDstPtr += pixelSize;
                }
                rightSrcPtr += centerStride;
                rightDstPtr += rightDstSkip;
            }
        }
 
        if (bottomHeight > 0) {
            const quint8 *bottomSrcPtr = patchData + ((centerHeight - 1) * centerStride);
            quint8 *bottomDstPtr = bufData + ((topHeight + centerHeight) * bufStride) + leftStride;
            for (int y = 0; y < bottomHeight; ++y) {
                memcpy(bottomDstPtr, bottomSrcPtr, centerStride);
                bottomDstPtr += bufStride;
            }
        }
 
        const GLvoid *fd = bufData;
        KisOpenGLBufferCircularStorage::BufferBinder b(m_bufferStorage, &fd, buf.size());
        f->glTexSubImage2D(GL_TEXTURE_2D,
                           patchLevelOfDetail,
                           patchOffset.x() - leftWidth,
                           patchOffset.y() - topHeight,
                           bufWidth,
                           bufHeight,
                           m_texturesInfo->format,
                           m_texturesInfo->type,
                           fd);
 
    } else if (updateInfo.isEntireTileUpdated()) {
        const GLvoid *fd = updateInfo.data();
        KisOpenGLBufferCircularStorage::BufferBinder b(
            m_bufferStorage, &fd, updateInfo.patchPixelsLength());
 
        f->glTexImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                     m_texturesInfo->internalFormat,
                     patchSize.width(),
                     patchSize.height(), 0,
                     m_texturesInfo->format,
                     m_texturesInfo->type,
                     fd);
 
    } else {
        const GLvoid *fd = updateInfo.data();
        const int size = centerWidth * centerHeight * pixelSize;
        KisOpenGLBufferCircularStorage::BufferBinder b(
            m_bufferStorage, &fd, size);
 
        f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                        patchOffset.x(), patchOffset.y(),
                        patchSize.width(), patchSize.height(),
                        m_texturesInfo->format,
                        m_texturesInfo->type,
                        fd);
    }
 
    // if (!updateInfo.isEntireTileUpdated() &&
    //     !(!patchLevelOfDetail || !m_preparedLodPlane || patchLevelOfDetail == m_preparedLodPlane)) {
    //     qDebug() << "WARNING: LodN switch is requested for the partial tile update!. Flickering is possible..." << ppVar(patchSize);
    //     qDebug() << "    " << ppVar(m_preparedLodPlane);
    //     qDebug() << "    " << ppVar(patchLevelOfDetail);
    // }
 
    restoreTextureParameters();
 
    if (!patchLevelOfDetail) {
        if (m_mipmapHasBeenAllocated &&
                (m_filter == KisOpenGL::BilinearFilterMode ||
                 m_filter == KisOpenGL::NearestFilterMode)) {
            setPreparedLodPlane(0);
        } else {
            setNeedsMipmapRegeneration();
        }
    } else {
        setPreparedLodPlane(patchLevelOfDetail);
    }
}

Member Data Documentation

◆ f

QOpenGLFunctions* KisTextureTile::f

private

Definition at line 97 of file kis_texture_tile.h.

◆ m_bufferStorage

KisOpenGLBufferCircularStorage* KisTextureTile::m_bufferStorage

private

Definition at line 98 of file kis_texture_tile.h.

◆ m_filter

KisOpenGL::FilterMode KisTextureTile::m_filter

private

Definition at line 92 of file kis_texture_tile.h.

◆ m_mipmapHasBeenAllocated

bool KisTextureTile::m_mipmapHasBeenAllocated = false

private

Definition at line 99 of file kis_texture_tile.h.

◆ m_needsMipmapRegeneration

bool KisTextureTile::m_needsMipmapRegeneration

private

Definition at line 94 of file kis_texture_tile.h.

◆ m_numMipmapLevels

int KisTextureTile::m_numMipmapLevels

private

Definition at line 96 of file kis_texture_tile.h.

◆ m_preparedLodPlane

int KisTextureTile::m_preparedLodPlane

private

Definition at line 95 of file kis_texture_tile.h.

◆ m_textureId

GLuint KisTextureTile::m_textureId

private

Definition at line 87 of file kis_texture_tile.h.

◆ m_textureRectInImagePixels

QRect KisTextureTile::m_textureRectInImagePixels

private

Definition at line 91 of file kis_texture_tile.h.

◆ m_texturesInfo

const KisGLTexturesInfo* KisTextureTile::m_texturesInfo

private

Definition at line 93 of file kis_texture_tile.h.

◆ m_tileRectInImagePixels

QRect KisTextureTile::m_tileRectInImagePixels

private

Definition at line 89 of file kis_texture_tile.h.

◆ m_tileRectInTexturePixels

QRectF KisTextureTile::m_tileRectInTexturePixels

private

Definition at line 90 of file kis_texture_tile.h.

The documentation for this class was generated from the following files:

libs/ui/opengl/kis_texture_tile.h
libs/ui/opengl/kis_texture_tile.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisTextureTile()

◆ ~KisTextureTile()

Member Function Documentation

◆ bindToActiveTexture()

◆ imageRectInTexturePixels()

◆ regenerateMipmap()

◆ restoreTextureParameters()

◆ setBufferStorage()

◆ setNeedsMipmapRegeneration()

◆ setNumMipmapLevels()

◆ setPreparedLodPlane()

◆ setTextureParameters()

◆ textureRectInImagePixels()

◆ tileRectInImagePixels()

◆ tileRectInTexturePixels()

◆ update()

Member Data Documentation

◆ f

◆ m_bufferStorage

◆ m_filter

◆ m_mipmapHasBeenAllocated

◆ m_needsMipmapRegeneration

◆ m_numMipmapLevels

◆ m_preparedLodPlane

◆ m_textureId

◆ m_textureRectInImagePixels

◆ m_texturesInfo

◆ m_tileRectInImagePixels

◆ m_tileRectInTexturePixels