#include <kis_opengl_image_textures.h>

Inheritance diagram for KisOpenGLImageTextures:

Signals
void	sigShowFloatingMessage (const QString &message, int timeout, bool priority)

Public Member Functions
GLuint	checkerTexture ()

void	generateCheckerTexture (const QImage &checkImage)

int	getTextureBufferIndexCR (int col, int row)

KisTextureTile *	getTextureTileCR (int col, int row)

KisImageSP	image () const

void	initGL (QOpenGLFunctions *f)

bool	internalColorManagementActive () const

	KisOpenGLImageTextures ()

const KoColorProfile *	monitorProfile ()

void	recalculateCache (KisUpdateInfoSP info, bool blockMipmapRegeneration)

void	setChannelFlags (const QBitArray &channelFlags)

bool	setImageColorSpace (const KoColorSpace *cs)

bool	setInternalColorManagementActive (bool value)

void	setMonitorProfile (const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)

void	setProofingConfig (KisProofingConfigurationSP)

void	slotImageSizeChanged (qint32 w, qint32 h)

QRect	storedImageBounds ()

void	testingForceInitialized ()

qreal	texelSize () const

QOpenGLBuffer *	tileTexCoordBuffer ()

QOpenGLBuffer *	tileVertexBuffer ()

KisOpenGLUpdateInfoSP	updateCache (const QRect &rect, KisImageSP srcImage)

KisOpenGLUpdateInfoSP	updateCacheNoConversion (const QRect &rect)

void	updateConfig (bool useBuffer, int NumMipmapLevels)

KisOpenGLUpdateInfoBuilder &	updateInfoBuilder ()

int	xToCol (int x)

int	yToRow (int y)

virtual	~KisOpenGLImageTextures ()

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static KisOpenGLImageTexturesSP	createImageTextures (KisImageWSP image, const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)

Static Public Attributes
static const int	BACKGROUND_TEXTURE_CHECK_SIZE = 32

static const int	BACKGROUND_TEXTURE_SIZE = BACKGROUND_TEXTURE_CHECK_SIZE * 2

Protected Member Functions
void	destroyImageTextureTiles ()

void	initBufferStorage (bool useBuffer)

	KisOpenGLImageTextures (KisImageWSP image, const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)

void	recreateImageTextureTiles ()

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Private Member Functions
void	getTextureSize (KisGLTexturesInfo *texturesInfo)

KisOpenGLUpdateInfoSP	updateCacheImpl (const QRect &rect, KisImageSP srcImage, bool convertColorSpace)

void	updateTextureFormat ()

Private Attributes
KisOpenGLBufferCircularStorage	m_bufferStorage

boost::optional< GLuint >	m_checkerTexture

KoColorConversionTransformation::ConversionFlags	m_conversionFlags

QOpenGLFunctions *	m_glFuncs {nullptr}

KisImageWSP	m_image

bool	m_initialized {false}

bool	m_internalColorManagementActive {true}

const KoColorProfile *	m_monitorProfile {nullptr}

int	m_numCols {0}

KoColorConversionTransformation::Intent	m_renderingIntent

QRect	m_storedImageBounds

KisGLTexturesInfo	m_texturesInfo

QVector< KisTextureTile * >	m_textureTiles

QOpenGLBuffer	m_tileTexCoordBuffer

QOpenGLBuffer	m_tileVertexBuffer

KisOpenGLUpdateInfoBuilder	m_updateInfoBuilder

bool	m_useOcio {false}

Detailed Description

A set of OpenGL textures that contains the projection of a KisImage.

Definition at line 36 of file kis_opengl_image_textures.h.

Constructor & Destructor Documentation

◆ KisOpenGLImageTextures() [1/2]

KisOpenGLImageTextures::KisOpenGLImageTextures ( )

Default constructor.

Definition at line 71 of file kis_opengl_image_textures.cpp.

    : m_image(0)
    , m_monitorProfile(0)
    , m_internalColorManagementActive(true)
    , m_bufferStorage(QOpenGLBuffer::PixelUnpackBuffer)
    , m_glFuncs(0)
    , m_useOcio(false)
    , m_initialized(false)
{
    KisConfig cfg(true);
    m_renderingIntent = (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 
    m_conversionFlags = KoColorConversionTransformation::HighQuality;
    if (cfg.useBlackPointCompensation()) m_conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
    if (!cfg.allowLCMSOptimization()) m_conversionFlags |= KoColorConversionTransformation::NoOptimization;
    m_useOcio = cfg.useOcio();
}

References KisConfig::allowLCMSOptimization(), KoColorConversionTransformation::BlackpointCompensation, KoColorConversionTransformation::HighQuality, m_conversionFlags, m_renderingIntent, m_useOcio, KisConfig::monitorRenderIntent(), KoColorConversionTransformation::NoOptimization, KisConfig::useBlackPointCompensation(), and KisConfig::useOcio().

◆ ~KisOpenGLImageTextures()

KisOpenGLImageTextures::~KisOpenGLImageTextures ( )

virtual

Destructor.

Definition at line 129 of file kis_opengl_image_textures.cpp.

{
    destroyImageTextureTiles();
    if (m_checkerTexture) {
        m_glFuncs->glDeleteTextures(1, &(*m_checkerTexture));
    }
}

References destroyImageTextureTiles(), m_checkerTexture, and m_glFuncs.

◆ KisOpenGLImageTextures() [2/2]

KisOpenGLImageTextures::KisOpenGLImageTextures	(	KisImageWSP	image,
		const KoColorProfile *	monitorProfile,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags )

protected

Definition at line 89 of file kis_opengl_image_textures.cpp.

    : m_image(image)
    , m_monitorProfile(monitorProfile)
    , m_renderingIntent(renderingIntent)
    , m_conversionFlags(conversionFlags)
    , m_internalColorManagementActive(true)
    , m_bufferStorage(QOpenGLBuffer::PixelUnpackBuffer)
    , m_glFuncs(0)
    , m_useOcio(false)
    , m_initialized(false)
{
    Q_ASSERT(renderingIntent < 4);
}

Member Function Documentation

◆ checkerTexture()

GLuint KisOpenGLImageTextures::checkerTexture ( )

Definition at line 393 of file kis_opengl_image_textures.cpp.

{
    if (m_glFuncs) {
        if (!m_checkerTexture) {
            m_checkerTexture = GLuint();
            m_glFuncs->glGenTextures(1, &(*m_checkerTexture));
        }
        return *m_checkerTexture;
    }
    else {
        dbgUI << "Tried to access checker texture before OpenGL was initialized";
        return 0;
    }
}

References dbgUI, m_checkerTexture, and m_glFuncs.

◆ createImageTextures()

KisOpenGLImageTexturesSP KisOpenGLImageTextures::createImageTextures	(	KisImageWSP	image,
		const KoColorProfile *	monitorProfile,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags )

static

Obtain a KisOpenGLImageTextures object for the given image.

Parameters

image	The image
monitorProfile	The profile of the display device
renderingIntent	The rendering intent
conversionFlags	The color conversion flags

Definition at line 158 of file kis_opengl_image_textures.cpp.

{
    return new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
}

References image(), KisOpenGLImageTextures(), and monitorProfile().

◆ destroyImageTextureTiles()

void KisOpenGLImageTextures::destroyImageTextureTiles ( )

protected

Definition at line 261 of file kis_opengl_image_textures.cpp.

{
    if (m_textureTiles.isEmpty()) return;
 
    Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
        delete tile;
    }
    m_textureTiles.clear();
    m_tileVertexBuffer.destroy();
    m_tileTexCoordBuffer.destroy();
    m_storedImageBounds = QRect();
}

References m_storedImageBounds, m_textureTiles, m_tileTexCoordBuffer, and m_tileVertexBuffer.

◆ generateCheckerTexture()

void KisOpenGLImageTextures::generateCheckerTexture ( const QImage & checkImage )

Generate a background texture from the given QImage. This is used for the checker pattern on which the image is rendered.

Definition at line 338 of file kis_opengl_image_textures.cpp.

{
    if (!m_initialized) {
        return;
    }
 
    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    if (ctx) {
        QOpenGLFunctions *f = ctx->functions();
        dbgUI << "Attaching checker texture" << checkerTexture();
        f->glBindTexture(GL_TEXTURE_2D, checkerTexture());
 
        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
        f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
        QImage img = checkImage;
        if (checkImage.width() != BACKGROUND_TEXTURE_SIZE || checkImage.height() != BACKGROUND_TEXTURE_SIZE) {
            img = checkImage.scaled(BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE);
        }
 
        // convert from sRGB to display format, potentially HDR
        const KoColorSpace *temporaryColorSpace = KoColorSpaceRegistry::instance()->rgb8();
        const KoColorSpace *finalColorSpace =
               KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(),
                                                            m_updateInfoBuilder.destinationColorSpace()->colorDepthId().id(),
                                                            m_monitorProfile);
 
        KisFixedPaintDevice checkers(temporaryColorSpace);
        checkers.convertFromQImage(img, temporaryColorSpace->profile()->name());
        checkers.convertTo(finalColorSpace);
 
        KIS_ASSERT(checkers.bounds().width() == BACKGROUND_TEXTURE_SIZE);
        KIS_ASSERT(checkers.bounds().height() == BACKGROUND_TEXTURE_SIZE);
 
        GLint format = m_texturesInfo.format;
        GLint internalFormat = m_texturesInfo.internalFormat;
        GLint type = m_texturesInfo.type;
 
        f->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE,
                        0, format, type, checkers.data());
 
        // QPainter::drawText relies on this.
        // Ref: https://bugreports.qt.io/browse/QTBUG-65496
        f->glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    }
    else {
        dbgUI << "OpenGL: Tried to generate checker texture before OpenGL was initialized.";
    }
 
}

References BACKGROUND_TEXTURE_SIZE, KisFixedPaintDevice::bounds(), checkerTexture(), KoColorSpace::colorDepthId(), KoColorSpaceRegistry::colorSpace(), KisFixedPaintDevice::convertFromQImage(), KisFixedPaintDevice::convertTo(), KisFixedPaintDevice::data(), dbgUI, KisOpenGLUpdateInfoBuilder::destinationColorSpace(), KisGLTexturesInfo::format, KoID::id(), KoColorSpaceRegistry::instance(), KisGLTexturesInfo::internalFormat, KIS_ASSERT, m_initialized, m_monitorProfile, m_texturesInfo, m_updateInfoBuilder, KoColorProfile::name, KoColorSpace::profile(), KoColorSpaceRegistry::rgb8(), RGBAColorModelID, and KisGLTexturesInfo::type.

◆ getTextureBufferIndexCR()

int KisOpenGLImageTextures::getTextureBufferIndexCR	(	int	col,
		int	row )

inline

Definition at line 133 of file kis_opengl_image_textures.h.

                                                         {
        if (m_initialized) {
            int tile = row * m_numCols + col;
            KIS_ASSERT_RECOVER_RETURN_VALUE(m_textureTiles.size() > tile, 0);
            return tile;
        }
        return -1;
    }

References KIS_ASSERT_RECOVER_RETURN_VALUE.

◆ getTextureSize()

void KisOpenGLImageTextures::getTextureSize ( KisGLTexturesInfo * texturesInfo )

private

Definition at line 506 of file kis_opengl_image_textures.cpp.

{
    KisConfig cfg(true);
 
    const GLint preferredTextureSize = cfg.openGLTextureSize();
 
    GLint maxTextureSize;
    if (m_glFuncs) {
        m_glFuncs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
    }
    else {
        dbgUI << "OpenGL: Tried to read texture size before OpenGL was initialized.";
        maxTextureSize = GL_MAX_TEXTURE_SIZE;
    }
 
    texturesInfo->width = qMin(preferredTextureSize, maxTextureSize);
    texturesInfo->height = qMin(preferredTextureSize, maxTextureSize);
 
    texturesInfo->border = cfg.textureOverlapBorder();
 
    texturesInfo->effectiveWidth = texturesInfo->width - 2 * texturesInfo->border;
    texturesInfo->effectiveHeight = texturesInfo->height - 2 * texturesInfo->border;
 
    m_updateInfoBuilder.setTextureBorder(texturesInfo->border);
    m_updateInfoBuilder.setEffectiveTextureSize(
        QSize(texturesInfo->effectiveWidth, texturesInfo->effectiveHeight));
}

References KisGLTexturesInfo::border, dbgUI, KisGLTexturesInfo::effectiveHeight, KisGLTexturesInfo::effectiveWidth, KisGLTexturesInfo::height, m_glFuncs, m_updateInfoBuilder, KisConfig::openGLTextureSize(), KisOpenGLUpdateInfoBuilder::setEffectiveTextureSize(), KisOpenGLUpdateInfoBuilder::setTextureBorder(), KisConfig::textureOverlapBorder(), and KisGLTexturesInfo::width.

◆ getTextureTileCR()

KisTextureTile * KisOpenGLImageTextures::getTextureTileCR	(	int	col,
		int	row )

inline

Definition at line 124 of file kis_opengl_image_textures.h.

                                                              {
        if (m_initialized) {
            int tile = row * m_numCols + col;
            KIS_ASSERT_RECOVER_RETURN_VALUE(m_textureTiles.size() > tile, 0);
            return m_textureTiles[tile];
        }
        return 0;
    }

References KIS_ASSERT_RECOVER_RETURN_VALUE.

◆ image()

KisImageSP KisOpenGLImageTextures::image ( ) const

Returns: the image associated with the textures

Definition at line 137 of file kis_opengl_image_textures.cpp.

{
    return m_image;
}

References m_image.

◆ initBufferStorage()

void KisOpenGLImageTextures::initBufferStorage ( bool useBuffer )

protected

Definition at line 142 of file kis_opengl_image_textures.cpp.

{
    if (useBuffer) {
        const int numTextureBuffers = 16;
 
        const KoColorSpace *tilesDestinationColorSpace =
            m_updateInfoBuilder.destinationColorSpace();
        const int pixelSize = tilesDestinationColorSpace->pixelSize();
        const int tileSize = m_texturesInfo.width * m_texturesInfo.height * pixelSize;
 
        m_bufferStorage.allocate(numTextureBuffers, tileSize);
    } else {
        m_bufferStorage.reset();
    }
}

References KisOpenGLBufferCircularStorage::allocate(), KisOpenGLUpdateInfoBuilder::destinationColorSpace(), KisGLTexturesInfo::height, m_bufferStorage, m_texturesInfo, m_updateInfoBuilder, KoColorSpace::pixelSize(), KisOpenGLBufferCircularStorage::reset(), and KisGLTexturesInfo::width.

◆ initGL()

void KisOpenGLImageTextures::initGL ( QOpenGLFunctions * f )

Complete initialization can only happen once an OpenGL context has been created.

Parameters

f	Pointer to OpenGL functions. They must already be initialized.

Definition at line 106 of file kis_opengl_image_textures.cpp.

{
    if (f) {
        m_glFuncs = f;
    } else {
        errUI << "Tried to create OpenGLImageTextures with uninitialized QOpenGLFunctions";
    }
 
    getTextureSize(&m_texturesInfo);
 
    // we use local static object for creating pools shared among
    // different images
    static KisTextureTileInfoPoolRegistry s_poolRegistry;
    m_updateInfoBuilder.setTextureInfoPool(s_poolRegistry.getPool(m_texturesInfo.width, m_texturesInfo.height));
 
    m_checkerTexture = GLuint();
    m_glFuncs->glGenTextures(1, &(*m_checkerTexture));
    recreateImageTextureTiles();
 
    KisOpenGLUpdateInfoSP info = updateCache(m_image->bounds(), m_image);
    recalculateCache(info, false);
}

References KisImage::bounds(), errUI, KisTextureTileInfoPoolRegistry::getPool(), getTextureSize(), KisGLTexturesInfo::height, m_checkerTexture, m_glFuncs, m_image, m_texturesInfo, m_updateInfoBuilder, recalculateCache(), recreateImageTextureTiles(), KisOpenGLUpdateInfoBuilder::setTextureInfoPool(), updateCache(), and KisGLTexturesInfo::width.

◆ internalColorManagementActive()

bool KisOpenGLImageTextures::internalColorManagementActive ( ) const

Definition at line 534 of file kis_opengl_image_textures.cpp.

{
    return m_internalColorManagementActive;
}

References m_internalColorManagementActive.

◆ monitorProfile()

const KoColorProfile * KisOpenGLImageTextures::monitorProfile ( )

Definition at line 447 of file kis_opengl_image_textures.cpp.

{
    return m_monitorProfile;
}

References m_monitorProfile.

◆ recalculateCache()

void KisOpenGLImageTextures::recalculateCache	(	KisUpdateInfoSP	info,
		bool	blockMipmapRegeneration )

Definition at line 291 of file kis_opengl_image_textures.cpp.

{
    if (!m_initialized) {
        dbgUI << "OpenGL: Tried to edit image texture cache before it was initialized.";
        return;
    }
 
    KisOpenGLUpdateInfoSP glInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
    if(!glInfo) return;
 
    QScopedPointer<KisOpenGLSync> sync;
    int numProcessedTiles = 0;
 
    KisTextureTileUpdateInfoSP tileInfo;
    Q_FOREACH (tileInfo, glInfo->tileList) {
        KisTextureTile *tile = getTextureTileCR(tileInfo->tileCol(), tileInfo->tileRow());
        KIS_ASSERT_RECOVER_RETURN(tile);
 
        if (m_bufferStorage.isValid() && numProcessedTiles > m_bufferStorage.size() &&
            sync && !sync->isSignaled()) {
 
#ifdef DEBUG_BUFFER_REALLOCATION
            qDebug() << "Still unsignalled after processed" << numProcessedTiles << "tiles";
#endif
 
            m_bufferStorage.allocateMoreBuffers();
 
#ifdef DEBUG_BUFFER_REALLOCATION
            qDebug() << "    increased number of buffers to" << m_bufferStorage.size();
#endif
        }
 
 
        tile->update(*tileInfo, blockMipmapRegeneration);
 
        if (m_bufferStorage.isValid()) {
            if (!sync) {
                sync.reset(new KisOpenGLSync());
                numProcessedTiles = 0;
            } else if (sync && sync->isSignaled()) {
                sync.reset();
            }
            numProcessedTiles++;
        }
    }
}

References KisOpenGLBufferCircularStorage::allocateMoreBuffers(), KisSharedPtr< T >::data(), dbgUI, getTextureTileCR(), KisOpenGLBufferCircularStorage::isValid(), KIS_ASSERT_RECOVER_RETURN, m_bufferStorage, m_initialized, KisOpenGLBufferCircularStorage::size(), KisOpenGLUpdateInfo::tileList, and KisTextureTile::update().

◆ recreateImageTextureTiles()

void KisOpenGLImageTextures::recreateImageTextureTiles ( )

protected

Definition at line 166 of file kis_opengl_image_textures.cpp.

{
 
    destroyImageTextureTiles();
    updateTextureFormat();
 
    const KoColorSpace *tilesDestinationColorSpace =
        m_updateInfoBuilder.destinationColorSpace();
 
    if (!tilesDestinationColorSpace) {
        qDebug() << "No destination colorspace!!!!";
        return;
    }
 
 
    m_storedImageBounds = m_image->bounds();
    const int lastCol = xToCol(m_image->width());
    const int lastRow = yToRow(m_image->height());
 
    m_numCols = lastCol + 1;
 
    // Default color is transparent black
    const int pixelSize = tilesDestinationColorSpace->pixelSize();
    QByteArray emptyTileData((m_texturesInfo.width) * (m_texturesInfo.height) * pixelSize, 0);
 
    KisConfig config(true);
    KisOpenGL::FilterMode mode = (KisOpenGL::FilterMode)config.openGLFilteringMode();
 
    initBufferStorage(KisOpenGL::shouldUseTextureBuffers(config.useOpenGLTextureBuffer()));
 
    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    if (ctx) {
        QOpenGLFunctions *f = ctx->functions();
 
        m_initialized = true;
        dbgUI  << "OpenGL: creating texture tiles of size" << m_texturesInfo.height << "x" << m_texturesInfo.width;
 
        QVector<QRectF> tileImageRect;
        QVector<QRectF> tileTextureRect;
 
        m_textureTiles.reserve((lastRow+1)*m_numCols);
 
        tileImageRect.reserve(m_textureTiles.size());
        tileTextureRect.reserve(m_textureTiles.size());
 
        for (int row = 0; row <= lastRow; row++) {
            for (int col = 0; col <= lastCol; col++) {
                QRect tileRect = m_updateInfoBuilder.calculateEffectiveTileRect(col, row, m_image->bounds());
 
                KisTextureTile *tile = new KisTextureTile(tileRect,
                                                          &m_texturesInfo,
                                                          emptyTileData,
                                                          mode,
                                                          m_bufferStorage.isValid() ? &m_bufferStorage : 0,
                                                          config.numMipmapLevels(),
                                                          f);
                m_textureTiles.append(tile);
                tileImageRect.append(tile->tileRectInImagePixels());
                tileTextureRect.append(tile->tileRectInTexturePixels());
            }
        }
 
 
 
        {
            KisOpenGLBufferCreationGuard bufferGuard(&m_tileVertexBuffer,
                                                     tileImageRect.size() * 6 * 3 * sizeof(float),
                                                     QOpenGLBuffer::StaticDraw);
 
            QVector3D* mappedPtr = reinterpret_cast<QVector3D*>(bufferGuard.data());
 
            Q_FOREACH (const QRectF &rc, tileImageRect) {
                KisPaintingTweaks::rectToVertices(mappedPtr, rc);
                mappedPtr += 6;
            }
        }
 
        {
            KisOpenGLBufferCreationGuard bufferGuard(&m_tileTexCoordBuffer,
                                                     tileImageRect.size() * 6 * 2 * sizeof(float),
                                                     QOpenGLBuffer::StaticDraw);
 
            QVector2D* mappedPtr = reinterpret_cast<QVector2D*>(bufferGuard.data());
 
            Q_FOREACH (const QRectF &rc, tileTextureRect) {
                KisPaintingTweaks::rectToTexCoords(mappedPtr, rc);
                mappedPtr += 6;
            }
        }
    }
    else {
        dbgUI << "Tried to init texture tiles without a current OpenGL Context.";
    }
}

References KisImage::bounds(), KisOpenGLUpdateInfoBuilder::calculateEffectiveTileRect(), KisOpenGLBufferCreationGuard::data(), dbgUI, KisOpenGLUpdateInfoBuilder::destinationColorSpace(), destroyImageTextureTiles(), KisImage::height(), KisGLTexturesInfo::height, initBufferStorage(), KisOpenGLBufferCircularStorage::isValid(), m_bufferStorage, m_image, m_initialized, m_numCols, m_storedImageBounds, m_texturesInfo, m_textureTiles, m_tileTexCoordBuffer, m_tileVertexBuffer, m_updateInfoBuilder, KisConfig::numMipmapLevels(), KisConfig::openGLFilteringMode(), KoColorSpace::pixelSize(), KisPaintingTweaks::rectToTexCoords(), KisPaintingTweaks::rectToVertices(), KisOpenGL::shouldUseTextureBuffers(), KisTextureTile::tileRectInImagePixels(), KisTextureTile::tileRectInTexturePixels(), updateTextureFormat(), KisConfig::useOpenGLTextureBuffer(), KisImage::width(), KisGLTexturesInfo::width, xToCol(), and yToRow().

◆ setChannelFlags()

void KisOpenGLImageTextures::setChannelFlags ( const QBitArray & channelFlags )

Definition at line 471 of file kis_opengl_image_textures.cpp.

{
    QBitArray targetChannelFlags = channelFlags;
    int selectedChannels = 0;
    const KoColorSpace *projectionCs = m_image->projection()->colorSpace();
    const QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
    if (targetChannelFlags.size() != channelInfo.size()) {
        targetChannelFlags = QBitArray();
    }
 
    int selectedChannelIndex = -1;
 
    for (int i = 0; i < targetChannelFlags.size(); ++i) {
        if (targetChannelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
            selectedChannels++;
            selectedChannelIndex = i;
        }
    }
    const bool allChannelsSelected = (selectedChannels == targetChannelFlags.size());
    const bool onlyOneChannelSelected = (selectedChannels == 1);
 
    // OCIO has its own channel swizzling
    if (allChannelsSelected || m_useOcio) {
        m_updateInfoBuilder.setChannelFlags(QBitArray(), false, -1);
    } else {
        m_updateInfoBuilder.setChannelFlags(targetChannelFlags, onlyOneChannelSelected, selectedChannelIndex);
    }
}

References KoColorSpace::channels, KoChannelInfo::COLOR, KisPaintDevice::colorSpace(), m_image, m_updateInfoBuilder, m_useOcio, KisImage::projection(), and KisOpenGLUpdateInfoBuilder::setChannelFlags().

◆ setImageColorSpace()

bool KisOpenGLImageTextures::setImageColorSpace ( const KoColorSpace * cs )

Update the textures when the color space of the image changes.

Returns: true when a full data refetch should be initiated by the caller

Definition at line 462 of file kis_opengl_image_textures.cpp.

{
    Q_UNUSED(cs);
    // TODO: implement lazy update: do not re-upload textures when not needed
 
    recreateImageTextureTiles();
    return true;
}

References recreateImageTextureTiles().

◆ setInternalColorManagementActive()

bool KisOpenGLImageTextures::setInternalColorManagementActive ( bool value )

Definition at line 539 of file kis_opengl_image_textures.cpp.

{
    bool needsFinalRegeneration = m_internalColorManagementActive != value;
 
    if (needsFinalRegeneration) {
        m_internalColorManagementActive = value;
        recreateImageTextureTiles();
 
        // at this point the value of m_internalColorManagementActive might
        // have been forcefully reverted to 'false' in case of some problems
    }
 
    return needsFinalRegeneration;
}

References m_internalColorManagementActive, recreateImageTextureTiles(), and value().

◆ setMonitorProfile()

void KisOpenGLImageTextures::setMonitorProfile	(	const KoColorProfile *	monitorProfile,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags )

Set the color profile of the display device.

Parameters

monitorProfile	The color profile of the display device
renderingIntent	The rendering intent
conversionFlags	The color conversion flags

Definition at line 452 of file kis_opengl_image_textures.cpp.

{
    //dbgUI << "Setting monitor profile to" << monitorProfile->name() << renderingIntent << conversionFlags;
    m_monitorProfile = monitorProfile;
    m_renderingIntent = renderingIntent;
    m_conversionFlags = conversionFlags;
 
    recreateImageTextureTiles();
}

References m_conversionFlags, m_monitorProfile, m_renderingIntent, monitorProfile(), and recreateImageTextureTiles().

◆ setProofingConfig()

void KisOpenGLImageTextures::setProofingConfig ( KisProofingConfigurationSP proofingConfig )

Definition at line 501 of file kis_opengl_image_textures.cpp.

{
    m_updateInfoBuilder.setProofingConfig(proofingConfig);
}

References m_updateInfoBuilder, and KisOpenGLUpdateInfoBuilder::setProofingConfig().

◆ sigShowFloatingMessage

void KisOpenGLImageTextures::sigShowFloatingMessage	(	const QString &	message,
		int	timeout,
		bool	priority )

signal

◆ slotImageSizeChanged()

void KisOpenGLImageTextures::slotImageSizeChanged	(	qint32	w,
		qint32	h )

Definition at line 437 of file kis_opengl_image_textures.cpp.

{
    recreateImageTextureTiles();
}

References recreateImageTextureTiles().

◆ storedImageBounds()

QRect KisOpenGLImageTextures::storedImageBounds ( )

inline

Definition at line 112 of file kis_opengl_image_textures.h.

                                     {
        return m_storedImageBounds;
    }

◆ testingForceInitialized()

void KisOpenGLImageTextures::testingForceInitialized ( )

Definition at line 421 of file kis_opengl_image_textures.cpp.

{
    m_initialized = true;
    m_updateInfoBuilder.setTextureInfoPool(toQShared(new KisTextureTileInfoPool(256, 256)));
 
    ConversionOptions options;
    options.m_destinationColorSpace = KoColorSpaceRegistry::instance()->rgb8();
    options.m_conversionFlags = KoColorConversionTransformation::internalConversionFlags();
    options.m_renderingIntent = KoColorConversionTransformation::internalRenderingIntent();
    options.m_needsConversion = false;
    m_updateInfoBuilder.setConversionOptions(options);
 
    m_updateInfoBuilder.setTextureBorder(4);
    m_updateInfoBuilder.setEffectiveTextureSize(QSize(248, 248));
}

References KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), ConversionOptions::m_conversionFlags, ConversionOptions::m_destinationColorSpace, m_initialized, ConversionOptions::m_needsConversion, ConversionOptions::m_renderingIntent, m_updateInfoBuilder, KoColorSpaceRegistry::rgb8(), KisOpenGLUpdateInfoBuilder::setConversionOptions(), KisOpenGLUpdateInfoBuilder::setEffectiveTextureSize(), KisOpenGLUpdateInfoBuilder::setTextureBorder(), KisOpenGLUpdateInfoBuilder::setTextureInfoPool(), and toQShared().

◆ texelSize()

qreal KisOpenGLImageTextures::texelSize ( ) const

inline

Definition at line 150 of file kis_opengl_image_textures.h.

                                   {
        Q_ASSERT(m_texturesInfo.width == m_texturesInfo.height);
        return 1.0 / m_texturesInfo.width;
    }

◆ tileTexCoordBuffer()

QOpenGLBuffer * KisOpenGLImageTextures::tileTexCoordBuffer ( )

inline

Definition at line 146 of file kis_opengl_image_textures.h.

                                        {
        return &m_tileTexCoordBuffer;
    }

◆ tileVertexBuffer()

QOpenGLBuffer * KisOpenGLImageTextures::tileVertexBuffer ( )

inline

Definition at line 142 of file kis_opengl_image_textures.h.

                                      {
        return &m_tileVertexBuffer;
    }

◆ updateCache()

KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCache	(	const QRect &	rect,
		KisImageSP	srcImage )

Definition at line 274 of file kis_opengl_image_textures.cpp.

{
    return updateCacheImpl(rect, srcImage, true);
}

References updateCacheImpl().

◆ updateCacheImpl()

KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheImpl	(	const QRect &	rect,
		KisImageSP	srcImage,
		bool	convertColorSpace )

private

Definition at line 285 of file kis_opengl_image_textures.cpp.

{
    if (!m_initialized) return new KisOpenGLUpdateInfo();
    return m_updateInfoBuilder.buildUpdateInfo(rect, srcImage, convertColorSpace);
}

References KisOpenGLUpdateInfoBuilder::buildUpdateInfo(), m_initialized, and m_updateInfoBuilder.

◆ updateCacheNoConversion()

KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheNoConversion ( const QRect & rect )

Definition at line 279 of file kis_opengl_image_textures.cpp.

{
    return updateCacheImpl(rect, m_image, false);
}

References m_image, and updateCacheImpl().

◆ updateConfig()

void KisOpenGLImageTextures::updateConfig	(	bool	useBuffer,
		int	NumMipmapLevels )

Definition at line 408 of file kis_opengl_image_textures.cpp.

{
    if(m_textureTiles.isEmpty()) return;
 
    const bool effectiveUseBuffer = KisOpenGL::shouldUseTextureBuffers(useBuffer);
    initBufferStorage(effectiveUseBuffer);
 
    Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
        tile->setBufferStorage(effectiveUseBuffer ? &m_bufferStorage : 0);
        tile->setNumMipmapLevels(NumMipmapLevels);
    }
}

References initBufferStorage(), m_bufferStorage, m_textureTiles, KisTextureTile::setBufferStorage(), KisTextureTile::setNumMipmapLevels(), and KisOpenGL::shouldUseTextureBuffers().

◆ updateInfoBuilder()

KisOpenGLUpdateInfoBuilder & KisOpenGLImageTextures::updateInfoBuilder ( )

Definition at line 442 of file kis_opengl_image_textures.cpp.

{
    return m_updateInfoBuilder;
}

References m_updateInfoBuilder.

◆ updateTextureFormat()

void KisOpenGLImageTextures::updateTextureFormat ( )

private

TODO: add an optimization so that the tile->convertTo() method would not be called when not needed (DK)

Definition at line 635 of file kis_opengl_image_textures.cpp.

{
    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    if (!(m_image && ctx)) return;
 
    if (!KisOpenGL::hasOpenGLES()) {
#ifndef QT_OPENGL_ES_2
        m_texturesInfo.internalFormat = GL_RGBA8;
        m_texturesInfo.type = GL_UNSIGNED_BYTE;
        m_texturesInfo.format = GL_BGRA;
#else
        KIS_ASSERT_X(false, "KisOpenGLImageTextures::updateTextureFormat",
                "Unexpected KisOpenGL::hasOpenGLES returned false");
#endif
    } else {
#ifdef QT_OPENGL_ES_2
        m_texturesInfo.internalFormat = GL_RGBA8;
        m_texturesInfo.type = GL_UNSIGNED_BYTE;
        m_texturesInfo.format = GL_RGBA;
#else
        m_texturesInfo.internalFormat = GL_BGRA8_EXT;
        m_texturesInfo.type = GL_UNSIGNED_BYTE;
        m_texturesInfo.format = GL_BGRA_EXT;
        if(!ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))) {
            // The red and blue channels are swapped, but it will be re-swapped
            // by texture swizzle mask set in KisTextureTile::setTextureParameters
            m_texturesInfo.internalFormat = GL_RGBA8;
            m_texturesInfo.type = GL_UNSIGNED_BYTE;
            m_texturesInfo.format = GL_RGBA;
        }
#endif
    }
 
    const bool useHDRMode = KisOpenGLModeProber::instance()->useHDRMode();
    const KoID colorModelId = m_image->colorSpace()->colorModelId();
    const KoID colorDepthId = useHDRMode ? Float16BitsColorDepthID : m_image->colorSpace()->colorDepthId();
 
    KoID destinationColorModelId = RGBAColorModelID;
    KoID destinationColorDepthId = Integer8BitsColorDepthID;
 
    dbgUI << "Choosing texture format:";
 
    if (colorModelId == RGBAColorModelID) {
        if (colorDepthId == Float16BitsColorDepthID) {
            initializeRGBA16FTextures(ctx, m_texturesInfo, destinationColorDepthId);
        }
        else if (colorDepthId == Float32BitsColorDepthID) {
            if (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3()) {
#ifndef QT_OPENGL_ES_2
                m_texturesInfo.internalFormat = GL_RGBA32F;
                dbgUI << "Using float (GLES or GL3)";
                m_texturesInfo.type = GL_FLOAT;
                m_texturesInfo.format = GL_RGBA;
                destinationColorDepthId = Float32BitsColorDepthID;
            } else if (ctx->hasExtension("GL_ARB_texture_float")) {
                m_texturesInfo.internalFormat = GL_RGBA32F_ARB;
                dbgUI << "Using ARB float";
                m_texturesInfo.type = GL_FLOAT;
                m_texturesInfo.format = GL_RGBA;
                destinationColorDepthId = Float32BitsColorDepthID;
            } else if (ctx->hasExtension("GL_ATI_texture_float")) {
                m_texturesInfo.internalFormat = GL_RGBA_FLOAT32_ATI;
                dbgUI << "Using ATI float";
                m_texturesInfo.type = GL_FLOAT;
                m_texturesInfo.format = GL_RGBA;
                destinationColorDepthId = Float32BitsColorDepthID;
#else
                if (ctx->format().majorVersion() >= 3) {
                    m_texturesInfo.internalFormat = GL_RGBA32F;
                    dbgUI << "Using float (GLES 3 non-Angle)";
                    m_texturesInfo.type = GL_FLOAT;
                    m_texturesInfo.format = GL_RGBA;
                    destinationColorDepthId = Float32BitsColorDepthID;
                    /* GL_EXT_texture_storage is GLES 2*/
                    /* GL_EXT_color_buffer_float is GLES 3*/
                } else if (ctx->hasExtension("GL_OES_texture_float")
                           && (ctx->hasExtension("GL_EXT_texture_storage") || ctx->hasExtension("EXT_color_buffer_float"))
                           && ctx->hasExtension("GL_OES_texture_float_linear")) {
                    m_texturesInfo.internalFormat = GL_RGBA32F_EXT;
                    dbgUI << "Using float (GLES v2)";
                    m_texturesInfo.type = GL_FLOAT;
                    m_texturesInfo.format = GL_RGBA;
                    destinationColorDepthId = Float32BitsColorDepthID;
                }
#endif
            }
        }
        else if (colorDepthId == Integer16BitsColorDepthID) {
            if (!KisOpenGL::hasOpenGLES()) {
#ifndef QT_OPENGL_ES_2
                m_texturesInfo.internalFormat = GL_RGBA16;
                m_texturesInfo.type = GL_UNSIGNED_SHORT;
 
                // On arm M1, GL_BGRA format is not aligned properly at the driver
                // changing the pixel format fixes the rendering problem when using
                // texture buffers
                // BUG: 445561
#ifdef Q_OS_MACOS
                m_texturesInfo.format = GL_RGBA;
#else
                m_texturesInfo.format = GL_BGRA;
#endif
                destinationColorDepthId = Integer16BitsColorDepthID;
                dbgUI << "Using 16 bits rgba";
#else
                KIS_ASSERT_X(false,
                             "KisOpenGLCanvas2::updateTextureFormat",
                             "Unexpected KisOpenGL::hasOpenGLES returned false");
#endif
            } else {
#ifdef EGL_ANGLE_platform_angle
                // If OpenGL ES, fall back to 16-bit float -- supports HDR
                // Angle does ship GL_EXT_texture_norm16 but it doesn't seem
                // to be renderable by DXGI - it returns a pixel size of 0
                initializeRGBA16FTextures(ctx, m_texturesInfo, destinationColorDepthId);
#else
                if (ctx->hasExtension("GL_EXT_texture_norm16")) {
                    m_texturesInfo.internalFormat = GL_RGBA16_EXT;
                    m_texturesInfo.type = GL_UNSIGNED_SHORT;
                    m_texturesInfo.format = GL_RGBA;
                    destinationColorDepthId = Integer16BitsColorDepthID;
                    dbgUI << "Using 16 bits rgba (GLES v2)";
                }
#endif
            }
        }
    }
    else {
        // We will convert the colorspace to 16 bits rgba, instead of 8 bits
        if (colorDepthId == Integer16BitsColorDepthID) {
            if (!KisOpenGL::hasOpenGLES()) {
#ifndef QT_OPENGL_ES_2
                m_texturesInfo.internalFormat = GL_RGBA16;
                m_texturesInfo.type = GL_UNSIGNED_SHORT;
                // On arm M1, GL_BGRA format is not aligned properly at the driver
                // changing the pixel format fixes the rendering problem when using
                // texture buffers
                // BUG: 445561
#ifdef Q_OS_MACOS
                m_texturesInfo.format = GL_RGBA;
#else
                m_texturesInfo.format = GL_BGRA;
#endif
                destinationColorDepthId = Integer16BitsColorDepthID;
                dbgUI << "Using conversion to 16 bits rgba";
#else
                KIS_ASSERT_X(false, "KisOpenGLCanvas2::updateTextureFormat",
                    "Unexpected KisOpenGL::hasOpenGLES returned false");
#endif
            } else {
#ifdef EGL_ANGLE_platform_angle
                // If OpenGL ES, fall back to 16-bit float -- supports HDR
                // Angle does ship GL_EXT_texture_norm16 but it doesn't seem
                // to be renderable by DXGI - it returns a pixel size of 0
                initializeRGBA16FTextures(ctx, m_texturesInfo, destinationColorDepthId);
#else
                if (ctx->hasExtension("GL_EXT_texture_norm16")) {
                    m_texturesInfo.internalFormat = GL_RGBA16_EXT;
                    m_texturesInfo.type = GL_UNSIGNED_SHORT;
                    m_texturesInfo.format = GL_RGBA;
                    destinationColorDepthId = Integer16BitsColorDepthID;
                    dbgUI << "Using conversion to 16 bits rgba (GLES v2)";
                }
#endif
            }
        } else if (colorDepthId == Float16BitsColorDepthID) {
            initializeRGBA16FTextures(ctx, m_texturesInfo, destinationColorDepthId);
        }
    }
 
    if (!m_internalColorManagementActive &&
            colorModelId != destinationColorModelId) {
 
        KisConfig cfg(false);
        KisConfig::OcioColorManagementMode cm = cfg.ocioColorManagementMode();
 
        if (cm != KisConfig::INTERNAL) {
            Q_EMIT sigShowFloatingMessage(
                i18n("OpenColorIO is disabled: image color space is not supported"), 5000, true);
        }
 
        warnUI << "WARNING: Internal color management was forcibly enabled";
        warnUI << "Color Management Mode: " << cm;
        warnUI << ppVar(m_image->colorSpace());
        warnUI << ppVar(destinationColorModelId);
        warnUI << ppVar(destinationColorDepthId);
 
        cfg.setOcioColorManagementMode(KisConfig::INTERNAL);
        m_internalColorManagementActive = true;
    }
 
    const KoColorProfile *profile =
            m_internalColorManagementActive ||
            colorModelId != destinationColorModelId ?
                m_monitorProfile : m_image->colorSpace()->profile();
 
    const KoColorSpace *tilesDestinationColorSpace =
            KoColorSpaceRegistry::instance()->colorSpace(destinationColorModelId.id(),
                                                         destinationColorDepthId.id(),
                                                         profile);
 
    m_updateInfoBuilder.setConversionOptions(
        ConversionOptions(tilesDestinationColorSpace,
                          m_renderingIntent,
                          m_conversionFlags));
}

References KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisImage::colorSpace(), KoColorSpaceRegistry::colorSpace(), dbgUI, Float16BitsColorDepthID, Float32BitsColorDepthID, KisGLTexturesInfo::format, GL_BGRA, GL_BGRA8_EXT, GL_BGRA_EXT, GL_RGBA16_EXT, KisOpenGL::hasOpenGL3(), KisOpenGL::hasOpenGLES(), KoID::id(), KoColorSpaceRegistry::instance(), KisOpenGLModeProber::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, KisConfig::INTERNAL, KisGLTexturesInfo::internalFormat, KIS_ASSERT_X, m_conversionFlags, m_image, m_internalColorManagementActive, m_monitorProfile, m_renderingIntent, m_texturesInfo, m_updateInfoBuilder, KisConfig::ocioColorManagementMode(), ppVar, KoColorSpace::profile(), RGBAColorModelID, KisOpenGLUpdateInfoBuilder::setConversionOptions(), KisConfig::setOcioColorManagementMode(), sigShowFloatingMessage(), KisGLTexturesInfo::type, KisOpenGLModeProber::useHDRMode(), and warnUI.

◆ xToCol()

int KisOpenGLImageTextures::xToCol ( int x )

inline

Definition at line 116 of file kis_opengl_image_textures.h.

                             {
        return x / m_texturesInfo.effectiveWidth;
    }

◆ yToRow()

int KisOpenGLImageTextures::yToRow ( int y )

inline

Definition at line 120 of file kis_opengl_image_textures.h.

                             {
        return y / m_texturesInfo.effectiveHeight;
    }

Member Data Documentation

◆ BACKGROUND_TEXTURE_CHECK_SIZE

const int KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE = 32

static

The background checkers texture.

Definition at line 97 of file kis_opengl_image_textures.h.

◆ BACKGROUND_TEXTURE_SIZE

const int KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE = BACKGROUND_TEXTURE_CHECK_SIZE * 2

static

Definition at line 98 of file kis_opengl_image_textures.h.

◆ m_bufferStorage

KisOpenGLBufferCircularStorage KisOpenGLImageTextures::m_bufferStorage

private

Definition at line 208 of file kis_opengl_image_textures.h.

◆ m_checkerTexture

boost::optional<GLuint> KisOpenGLImageTextures::m_checkerTexture

private

Definition at line 202 of file kis_opengl_image_textures.h.

◆ m_conversionFlags

KoColorConversionTransformation::ConversionFlags KisOpenGLImageTextures::m_conversionFlags

private

Definition at line 192 of file kis_opengl_image_textures.h.

◆ m_glFuncs

QOpenGLFunctions* KisOpenGLImageTextures::m_glFuncs {nullptr}

private

Definition at line 213 of file kis_opengl_image_textures.h.

213{nullptr};

◆ m_image

KisImageWSP KisOpenGLImageTextures::m_image

private

Definition at line 188 of file kis_opengl_image_textures.h.

◆ m_initialized

bool KisOpenGLImageTextures::m_initialized {false}

private

Definition at line 216 of file kis_opengl_image_textures.h.

216{false};

◆ m_internalColorManagementActive

bool KisOpenGLImageTextures::m_internalColorManagementActive {true}

private

Shows whether the internal color management should be enabled or not. Please note that if you disable color management, but your image color space will not be supported (non-RGB), then it will be enabled anyway. And this variable will hold the real state of affairs!

Definition at line 200 of file kis_opengl_image_textures.h.

200{true};

◆ m_monitorProfile

const KoColorProfile* KisOpenGLImageTextures::m_monitorProfile {nullptr}

private

Definition at line 190 of file kis_opengl_image_textures.h.

190{nullptr};

◆ m_numCols

int KisOpenGLImageTextures::m_numCols {0}

private

Definition at line 205 of file kis_opengl_image_textures.h.

205{0};

◆ m_renderingIntent

KoColorConversionTransformation::Intent KisOpenGLImageTextures::m_renderingIntent

private

Definition at line 191 of file kis_opengl_image_textures.h.

◆ m_storedImageBounds

QRect KisOpenGLImageTextures::m_storedImageBounds

private

Definition at line 189 of file kis_opengl_image_textures.h.

◆ m_texturesInfo

KisGLTexturesInfo KisOpenGLImageTextures::m_texturesInfo

private

Definition at line 204 of file kis_opengl_image_textures.h.

◆ m_textureTiles

QVector<KisTextureTile*> KisOpenGLImageTextures::m_textureTiles

private

Definition at line 209 of file kis_opengl_image_textures.h.

◆ m_tileTexCoordBuffer

QOpenGLBuffer KisOpenGLImageTextures::m_tileTexCoordBuffer

private

Definition at line 211 of file kis_opengl_image_textures.h.

◆ m_tileVertexBuffer

QOpenGLBuffer KisOpenGLImageTextures::m_tileVertexBuffer

private

Definition at line 210 of file kis_opengl_image_textures.h.

◆ m_updateInfoBuilder

KisOpenGLUpdateInfoBuilder KisOpenGLImageTextures::m_updateInfoBuilder

private

Definition at line 218 of file kis_opengl_image_textures.h.

◆ m_useOcio

bool KisOpenGLImageTextures::m_useOcio {false}

private

Definition at line 215 of file kis_opengl_image_textures.h.

215{false};

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

libs/ui/opengl/kis_opengl_image_textures.h
libs/ui/opengl/kis_opengl_image_textures.cpp

Signals

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisOpenGLImageTextures() [1/2]

◆ ~KisOpenGLImageTextures()

◆ KisOpenGLImageTextures() [2/2]

Member Function Documentation

◆ checkerTexture()

◆ createImageTextures()

◆ destroyImageTextureTiles()

◆ generateCheckerTexture()

◆ getTextureBufferIndexCR()

◆ getTextureSize()

◆ getTextureTileCR()

◆ image()

◆ initBufferStorage()

◆ initGL()

◆ internalColorManagementActive()

◆ monitorProfile()

◆ recalculateCache()

◆ recreateImageTextureTiles()

◆ setChannelFlags()

◆ setImageColorSpace()

◆ setInternalColorManagementActive()

◆ setMonitorProfile()

◆ setProofingConfig()

◆ sigShowFloatingMessage

◆ slotImageSizeChanged()

◆ storedImageBounds()

◆ testingForceInitialized()

◆ texelSize()

◆ tileTexCoordBuffer()

◆ tileVertexBuffer()

◆ updateCache()

◆ updateCacheImpl()

◆ updateCacheNoConversion()

◆ updateConfig()

◆ updateInfoBuilder()

◆ updateTextureFormat()

◆ xToCol()

◆ yToRow()

Member Data Documentation

◆ BACKGROUND_TEXTURE_CHECK_SIZE

◆ BACKGROUND_TEXTURE_SIZE

◆ m_bufferStorage

◆ m_checkerTexture

◆ m_conversionFlags

◆ m_glFuncs

◆ m_image

◆ m_initialized

◆ m_internalColorManagementActive

◆ m_monitorProfile

◆ m_numCols

◆ m_renderingIntent

◆ m_storedImageBounds

◆ m_texturesInfo

◆ m_textureTiles

◆ m_tileTexCoordBuffer

◆ m_tileVertexBuffer

◆ m_updateInfoBuilder

◆ m_useOcio