KisTextureTile Class Reference

#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 378 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.

On the boundaries of KisImage, there is a border-effect as well. So we just repeat the bounding pixels of the image to make bilinear interpolator happy.

WARN: The width of the stripes will be equal to the broader width of the tiles.

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->initializeOpenGLFunctions();
    f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
    setTextureParameters();
 
    const int patchLevelOfDetail = updateInfo.patchLevelOfDetail();
    const QSize patchSize = updateInfo.realPatchSize();
    const QPoint patchOffset = updateInfo.realPatchOffset();
 
    const GLvoid *fd = updateInfo.data();
 
    if (!blockMipmapRegeneration &&
        patchLevelOfDetail > 0 &&
        (m_needsMipmapRegeneration &&
         !updateInfo.isEntireTileUpdated())
            || !m_mipmapHasBeenAllocated) {
 
        regenerateMipmap();
    }
 
 
    if (updateInfo.isEntireTileUpdated()) {
        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 int size = patchSize.width() * patchSize.height() * updateInfo.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);
 
    }
 
    const int pixelSize = updateInfo.pixelSize();
    const QSize tileSize = updateInfo.realTileSize();
 
    if(updateInfo.isTopmost()) {
        int start = 0;
        int end = patchOffset.y() - 1;
 
        const GLvoid *fd = updateInfo.data();
        const int size = patchSize.width() * pixelSize;
        KisOpenGLBufferCircularStorage::BufferBinder g(
            m_bufferStorage, &fd, size);
 
        for (int i = start; i <= end; i++) {
            f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                               patchOffset.x(), i,
                               patchSize.width(), 1,
                               m_texturesInfo->format,
                               m_texturesInfo->type,
                               fd);
        }
    }
 
    if (updateInfo.isBottommost()) {
        int shift = patchSize.width() * (patchSize.height() - 1) *
                pixelSize;
 
        int start = patchOffset.y() + patchSize.height();
        int end = tileSize.height() - 1;
 
        const GLvoid *fd = updateInfo.data() + shift;
        const int size = patchSize.width() * pixelSize;
        KisOpenGLBufferCircularStorage::BufferBinder g(
            m_bufferStorage, &fd, size);
 
        for (int i = start; i < end; i++) {
            f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                            patchOffset.x(), i,
                            patchSize.width(), 1,
                            m_texturesInfo->format,
                            m_texturesInfo->type,
                            fd);
        }
    }
 
    if (updateInfo.isLeftmost()) {
 
        QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
 
        quint8 *srcPtr = updateInfo.data();
        quint8 *dstPtr = (quint8*) columnBuffer.data();
        for(int i = 0; i < patchSize.height(); i++) {
            memcpy(dstPtr, srcPtr, pixelSize);
 
            srcPtr += patchSize.width() * pixelSize;
            dstPtr += pixelSize;
        }
 
        int start = 0;
        int end = patchOffset.x() - 1;
 
        const GLvoid *fd = columnBuffer.constData();
        const int size = columnBuffer.size();
        KisOpenGLBufferCircularStorage::BufferBinder g(
            m_bufferStorage, &fd, size);
 
        for (int i = start; i <= end; i++) {
            f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                            i, patchOffset.y(),
                            1, patchSize.height(),
                            m_texturesInfo->format,
                            m_texturesInfo->type,
                            fd);
        }
    }
 
    if (updateInfo.isRightmost()) {
 
        QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
 
        quint8 *srcPtr = updateInfo.data() + (patchSize.width() - 1) * pixelSize;
        quint8 *dstPtr = (quint8*) columnBuffer.data();
        for(int i = 0; i < patchSize.height(); i++) {
            memcpy(dstPtr, srcPtr, pixelSize);
 
            srcPtr += patchSize.width() * pixelSize;
            dstPtr += pixelSize;
        }
 
        int start = patchOffset.x() + patchSize.width();
        int end = tileSize.width() - 1;
 
        const GLvoid *fd = columnBuffer.constData();
        const int size = columnBuffer.size();
        KisOpenGLBufferCircularStorage::BufferBinder g(
            m_bufferStorage, &fd, size);
 
        for (int i = start; i <= end; i++) {
            f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                            i, patchOffset.y(),
                            1, 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);
    }
}

References KisOpenGL::BilinearFilterMode, KisTextureTileUpdateInfo::data(), f, KisGLTexturesInfo::format, KisGLTexturesInfo::internalFormat, KisTextureTileUpdateInfo::isBottommost(), KisTextureTileUpdateInfo::isEntireTileUpdated(), KisTextureTileUpdateInfo::isLeftmost(), KisTextureTileUpdateInfo::isRightmost(), KisTextureTileUpdateInfo::isTopmost(), m_bufferStorage, m_filter, m_mipmapHasBeenAllocated, m_needsMipmapRegeneration, m_textureId, m_texturesInfo, KisOpenGL::NearestFilterMode, KisTextureTileUpdateInfo::patchLevelOfDetail(), KisTextureTileUpdateInfo::patchPixelsLength(), KisTextureTileUpdateInfo::pixelSize(), KisTextureTileUpdateInfo::realPatchOffset(), KisTextureTileUpdateInfo::realPatchSize(), KisTextureTileUpdateInfo::realTileSize(), regenerateMipmap(), restoreTextureParameters(), setNeedsMipmapRegeneration(), setPreparedLodPlane(), setTextureParameters(), and KisGLTexturesInfo::type.

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