KisOpenGL Class Reference

#include <kis_opengl.h>

Classes
struct	RendererConfig

Public Types
enum	AngleRenderer { AngleRendererDefault = 0x0000 , AngleRendererD3d11 = 0x0002 , AngleRendererD3d9 = 0x0004 , AngleRendererD3d11Warp = 0x0008 }
enum	FilterMode { NearestFilterMode , BilinearFilterMode , TrilinearFilterMode , HighQualityFiltering }
enum	OpenGLRenderer {   RendererNone = 0x00 , RendererAuto = 0x01 , RendererDesktopGL = 0x02 , RendererOpenGLES = 0x04 ,   RendererSoftware = 0x08 }
enum	XcbGLProviderProtocol { XCB_GLX = 0 , XCB_EGL }

Static Public Member Functions
static OpenGLRenderer	convertConfigToOpenGLRenderer (QString renderer)
static QString	convertOpenGLRendererToConfig (OpenGLRenderer renderer)
static QString	currentDriver ()
static bool	forceDisableTextureBuffers ()
static OpenGLRenderer	getCurrentOpenGLRenderer ()
static const QString &	getDebugText ()
static QStringList	getOpenGLWarnings ()
static OpenGLRenderer	getQtPreferredOpenGLRenderer ()
static OpenGLRenderers	getSupportedOpenGLRenderers ()
static OpenGLRenderer	getUserPreferredOpenGLRendererConfig ()
static void	glInvalidateBufferData (uint buffer)
static bool	hasOpenGL ()
	Check for OpenGL.
static bool	hasOpenGL3 ()
static bool	hasOpenGLES ()
static void	initialize ()
	Request OpenGL version 3.2.
static void	initializeContext (QOpenGLContext *ctx)
	Initialize shared OpenGL context.
static bool	needsFenceWorkaround ()
static RendererConfig	selectSurfaceConfig (KisOpenGL::OpenGLRenderer preferredRenderer, KisConfig::RootSurfaceFormat preferredRootSurfaceFormat, KisConfig::CanvasSurfaceBitDepthMode preferredCanvasSurfaceBitMode, bool enableDebug)
static void	setDebugSynchronous (bool value)
static void	setDefaultSurfaceConfig (const RendererConfig &config)
static void	setUserPreferredOpenGLRendererConfig (OpenGLRenderer renderer)
static bool	shouldUseTextureBuffers (bool userPreference)
static bool	supportsBufferMapping ()
static bool	supportsFenceSync ()
	supportsFilter
static bool	supportsLoD ()
static bool	supportsVAO ()
static void	testingInitializeDefaultSurfaceFormat ()
static bool	useFBOForToolOutlineRendering ()
	supportsRenderToFBO
static bool	useTextureBufferInvalidation ()
static std::optional< XcbGLProviderProtocol >	xcbGlProviderProtocol ()

Private Member Functions
	KisOpenGL ()

Static Private Member Functions
static void	fakeInitWindowsOpenGL (KisOpenGL::OpenGLRenderers supportedRenderers, KisOpenGL::OpenGLRenderer preferredByQt)

Detailed Description

This class manages a shared OpenGL context and provides utility functions for checking capabilities and error reporting.

Definition at line 30 of file kis_opengl.h.

Member Enumeration Documentation

AngleRenderer

enum KisOpenGL::AngleRenderer

Enumerator
AngleRendererDefault
AngleRendererD3d11
AngleRendererD3d9
AngleRendererD3d11Warp

Definition at line 49 of file kis_opengl.h.

                       {
        AngleRendererDefault    = 0x0000,
        AngleRendererD3d11      = 0x0002,
        AngleRendererD3d9       = 0x0004,
        AngleRendererD3d11Warp  = 0x0008, // "Windows Advanced Rasterization Platform"
    };

FilterMode

enum KisOpenGL::FilterMode

Enumerator
NearestFilterMode
BilinearFilterMode
TrilinearFilterMode
HighQualityFiltering

Definition at line 33 of file kis_opengl.h.

                    {
        NearestFilterMode,  // nearest
        BilinearFilterMode, // linear, no mipmap
        TrilinearFilterMode, // LINEAR_MIPMAP_LINEAR
        HighQualityFiltering // Mipmaps + custom shader
    };

OpenGLRenderer

enum KisOpenGL::OpenGLRenderer

Enumerator
RendererNone
RendererAuto
RendererDesktopGL
RendererOpenGLES
RendererSoftware

Definition at line 40 of file kis_opengl.h.

                        {
        RendererNone = 0x00,
        RendererAuto = 0x01,
        RendererDesktopGL = 0x02,
        RendererOpenGLES = 0x04,
        RendererSoftware = 0x08
    };

XcbGLProviderProtocol

enum KisOpenGL::XcbGLProviderProtocol

Enumerator
XCB_GLX
XCB_EGL

Definition at line 63 of file kis_opengl.h.

                               {
        XCB_GLX = 0,
        XCB_EGL
    };

Constructor & Destructor Documentation

KisOpenGL()

KisOpenGL::KisOpenGL ( )

private

Member Function Documentation

convertConfigToOpenGLRenderer()

KisOpenGL::OpenGLRenderer KisOpenGL::convertConfigToOpenGLRenderer ( QString renderer )

static

Definition at line 492 of file kis_opengl.cpp.

{
    if (renderer == "desktop") {
        return RendererDesktopGL;
    } else if (renderer == "angle") {
        return RendererOpenGLES;
    } else if (renderer == "software") {
        return RendererSoftware;
    } else if (renderer == "none") {
        return RendererNone;
    } else {
        return RendererAuto;
    }
}

References RendererAuto, RendererDesktopGL, RendererNone, RendererOpenGLES, and RendererSoftware.

convertOpenGLRendererToConfig()

QString KisOpenGL::convertOpenGLRendererToConfig ( KisOpenGL::OpenGLRenderer renderer )

static

Definition at line 476 of file kis_opengl.cpp.

{
    switch (renderer) {
    case RendererNone:
        return QStringLiteral("none");
    case RendererSoftware:
        return QStringLiteral("software");
    case RendererDesktopGL:
        return QStringLiteral("desktop");
    case RendererOpenGLES:
        return QStringLiteral("angle");
    default:
        return QStringLiteral("auto");
    }
}

References RendererDesktopGL, RendererNone, RendererOpenGLES, and RendererSoftware.

currentDriver()

QString KisOpenGL::currentDriver ( )

static

Definition at line 347 of file kis_opengl.cpp.

{
    initialize();
    if (openGLCheckResult) {
        return openGLCheckResult->driverVersionString();
    }
    return QString();
}

References initialize().

fakeInitWindowsOpenGL()

static void KisOpenGL::fakeInitWindowsOpenGL ( KisOpenGL::OpenGLRenderers supportedRenderers, KisOpenGL::OpenGLRenderer preferredByQt )

staticprivate

forceDisableTextureBuffers()

bool KisOpenGL::forceDisableTextureBuffers ( )

static

Definition at line 394 of file kis_opengl.cpp.

{
    initialize();
    return g_forceDisableTextureBuffers;
}

References initialize().

getCurrentOpenGLRenderer()

KisOpenGL::OpenGLRenderer KisOpenGL::getCurrentOpenGLRenderer ( )

static

Definition at line 446 of file kis_opengl.cpp.

{
    if (!openGLCheckResult) return RendererAuto;
    return getRendererFromProbeResult(*openGLCheckResult);
}

References RendererAuto.

getDebugText()

const QString & KisOpenGL::getDebugText ( )

static

Definition at line 333 of file kis_opengl.cpp.

{
    initialize();
    return g_debugText;
}

References initialize().

getOpenGLWarnings()

QStringList KisOpenGL::getOpenGLWarnings ( )

static

Definition at line 339 of file kis_opengl.cpp.

                                         {
    QStringList strings;
    Q_FOREACH (const KLocalizedString &item, g_openglWarningStrings) {
        strings << item.toString();
    }
    return strings;
}

getQtPreferredOpenGLRenderer()

KisOpenGL::OpenGLRenderer KisOpenGL::getQtPreferredOpenGLRenderer ( )

static

Definition at line 452 of file kis_opengl.cpp.

{
    return g_rendererPreferredByQt;
}

getSupportedOpenGLRenderers()

KisOpenGL::OpenGLRenderers KisOpenGL::getSupportedOpenGLRenderers ( )

static

Definition at line 457 of file kis_opengl.cpp.

{
    return g_supportedRenderers;
}

getUserPreferredOpenGLRendererConfig()

KisOpenGL::OpenGLRenderer KisOpenGL::getUserPreferredOpenGLRendererConfig ( )

static

Definition at line 462 of file kis_opengl.cpp.

{
    const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
    QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
    return convertConfigToOpenGLRenderer(kritarc.value("OpenGLRenderer", "auto").toString());
}

References convertConfigToOpenGLRenderer().

glInvalidateBufferData()

void KisOpenGL::glInvalidateBufferData ( uint buffer )

static

Definition at line 441 of file kis_opengl.cpp.

{
    g_glInvalidateBufferData(buffer);
}

hasOpenGL()

bool KisOpenGL::hasOpenGL ( )

static

Check for OpenGL.

Definition at line 1212 of file kis_opengl.cpp.

{
    return openGLCheckResult->isSupportedVersion();
}

hasOpenGL3()

bool KisOpenGL::hasOpenGL3 ( )

static

Definition at line 364 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult && openGLCheckResult->hasOpenGL3();
}

References initialize().

hasOpenGLES()

bool KisOpenGL::hasOpenGLES ( )

static

Definition at line 376 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult && openGLCheckResult->isOpenGLES();
}

References initialize().

initialize()

void KisOpenGL::initialize ( )

static

Request OpenGL version 3.2.

The large pixmap cache workaround was originally added to fix the bug 361709 and later extended to all GPU/OS configurations. This setting is still left here in case anyone finds the cached method performing better that the direct drawing of assistants onto the canvas.

See bugs: https://bugs.kde.org/show_bug.cgi?id=361709 https://bugs.kde.org/show_bug.cgi?id=401940

Definition at line 139 of file kis_opengl.cpp.

{
    if (openGLCheckResult) return;
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(g_sanityDefaultFormatIsSet);
 
    KisOpenGL::RendererConfig config;
    config.format = QSurfaceFormat::defaultFormat();
 
    openGLCheckResult =
        KisOpenGLModeProber::instance()->probeFormat(config, false);
 
#ifdef Q_OS_WIN
 
    if (!qEnvironmentVariableIsSet("KRITA_UNLOCK_TEXTURE_BUFFERS") &&
        openGLCheckResult->rendererString().toUpper().contains("ANGLE")) {
 
        // Angle should always be openGLES...
        KIS_SAFE_ASSERT_RECOVER_NOOP(KisOpenGL::hasOpenGLES());
 
        g_forceDisableTextureBuffers = true;
        appendOpenGLWarningString(
            ki18n("Texture buffers are explicitly disabled on ANGLE renderer due "
                  "to performance issues."));
    }
#endif
 
 
    g_debugText.clear();
    QDebug debugOut(&g_debugText);
    debugOut << "OpenGL Info\n";
 
    if (openGLCheckResult) {
        debugOut << "\n  Qt Platform Name: " << QGuiApplication::platformName();
        if (openGLCheckResult->xcbGlProviderProtocol()) {
            debugOut << "\n  Qt XCB GL integration plugin: "
                     << (*openGLCheckResult->xcbGlProviderProtocol() == KisOpenGL::XCB_EGL ? "xcb_egl" : "xcb_glx");
        }
        debugOut << "\n  Vendor: " << openGLCheckResult->vendorString();
        debugOut << "\n  Renderer: " << openGLCheckResult->rendererString();
        debugOut << "\n  Driver version: " << openGLCheckResult->driverVersionString();
        debugOut << "\n  Shading language: " << openGLCheckResult->shadingLanguageString();
        debugOut << "\n  Requested format: " << QSurfaceFormat::defaultFormat();
        debugOut << "\n  Current format: " << openGLCheckResult->format();
        {
            QDebugStateSaver saver(debugOut);
            debugOut.nospace() << "\n  GL version: " << openGLCheckResult->glMajorVersion() << "."
                               << openGLCheckResult->glMinorVersion();
        }
        debugOut << "\n  Supports deprecated functions" << openGLCheckResult->supportsDeprecatedFunctions();
        debugOut << "\n  Is OpenGL ES:" << openGLCheckResult->isOpenGLES();
        debugOut << "\n  supportsBufferMapping:" << openGLCheckResult->supportsBufferMapping();
        debugOut << "\n  supportsBufferInvalidation:" << openGLCheckResult->supportsBufferInvalidation();
        debugOut << "\n  forceDisableTextureBuffers:" << g_forceDisableTextureBuffers;
        debugOut << "\n  Extensions:";
        {
            QDebugStateSaver saver(debugOut);
            Q_FOREACH (const QByteArray &i, openGLCheckResult->extensions()) {
                debugOut.noquote() << "\n    " << QString::fromLatin1(i);
            }
        }
    }
 
    debugOut << "\n\nQPA OpenGL Detection Info";
    debugOut << "\n  supportsDesktopGL:" << bool(g_supportedRenderers & RendererDesktopGL);
#ifdef Q_OS_WIN
    debugOut << "\n  supportsAngleD3D11:" << bool(g_supportedRenderers & RendererOpenGLES);
    debugOut << "\n  isQtPreferAngle:" << bool(g_rendererPreferredByQt == RendererOpenGLES);
#else
    debugOut << "\n  supportsOpenGLES:" << bool(g_supportedRenderers & RendererOpenGLES);
    debugOut << "\n  isQtPreferOpenGLES:" << bool(g_rendererPreferredByQt == RendererOpenGLES);
#endif
    debugOut << "\n  Detected renderers:";
    {
        QDebugStateSaver saver(debugOut);
        Q_FOREACH (const DetectedRenderer &x, g_detectedRenderers) {
            debugOut.noquote().nospace() << "\n    " << (std::get<2>(x) ? "(Supported)" : "(Unsupported)") << " "
                                         << std::get<0>(x) << " (" << std::get<1>(x) << ") ";
        }
    }
 
//    debugOut << "\n== log ==\n";
//    debugOut.noquote();
//    debugOut << g_surfaceFormatDetectionLog;
//    debugOut.resetFormat();
//    debugOut << "\n== end log ==";
 
    dbgOpenGL.noquote().nospace() << g_debugText;
    KisUsageLogger::writeSysInfo(g_debugText);
 
    if (!openGLCheckResult) {
        return;
    }
 
 
    // Check if we have a bugged driver that needs fence workaround
    bool isOnX11 = false;
#ifdef HAVE_X11
    isOnX11 = true;
#endif
 
    KisConfig cfg(true);
 
    g_useBufferInvalidation = cfg.readEntry("useBufferInvalidation", false);
    KisUsageLogger::writeSysInfo(QString("\nuseBufferInvalidation (config option): %1\n").arg(g_useBufferInvalidation ? "true" : "false"));
 
    if ((isOnX11 && openGLCheckResult->rendererString().startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) {
        g_needsFenceWorkaround = true;
    }
 
    if (cfg.assistantsDrawMode() == KisConfig::ASSISTANTS_DRAW_MODE_LARGE_PIXMAP_CACHE) {
        const qreal devicePixelRatio = QGuiApplication::primaryScreen()->devicePixelRatio();
        const QSize screenSize = QGuiApplication::primaryScreen()->size() * devicePixelRatio;
        const int minCacheSize = 20 * 1024;
 
        // reserve space for at least 4 textures
        const int cacheSize = 2048 + 5 * 4 * screenSize.width() * screenSize.height() / 1024; // KiB
 
        QPixmapCache::setCacheLimit(qMax(minCacheSize, cacheSize));
    }
}

References KisConfig::ASSISTANTS_DRAW_MODE_LARGE_PIXMAP_CACHE, KisConfig::assistantsDrawMode(), dbgOpenGL, KisConfig::forceOpenGLFenceWorkaround(), KisOpenGL::RendererConfig::format, hasOpenGLES(), KisOpenGLModeProber::instance(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisOpenGLModeProber::probeFormat(), KisConfig::readEntry(), RendererDesktopGL, RendererOpenGLES, KisUsageLogger::writeSysInfo(), and XCB_EGL.

initializeContext()

void KisOpenGL::initializeContext ( QOpenGLContext * ctx )

static

Initialize shared OpenGL context.

Definition at line 284 of file kis_opengl.cpp.

{
    KisConfig cfg(true);
    initialize();
 
    const bool isDebugEnabled = ctx->format().testOption(QSurfaceFormat::DebugContext);
 
    dbgUI << "OpenGL: Opening new context";
    if (isDebugEnabled) {
        // Passing ctx for ownership management only, not specifying context.
        // QOpenGLDebugLogger only function on the current active context.
        // FIXME: Do we need to make sure ctx is the active context?
        QOpenGLDebugLogger* openglLogger = new QOpenGLDebugLogger(ctx);
        if (openglLogger->initialize()) {
            qDebug() << "QOpenGLDebugLogger is initialized. Check whether you get a message below.";
            QObject::connect(openglLogger, &QOpenGLDebugLogger::messageLogged, &openglOnMessageLogged);
            openglLogger->startLogging(g_isDebugSynchronous ? QOpenGLDebugLogger::SynchronousLogging : QOpenGLDebugLogger::AsynchronousLogging);
            openglLogger->logMessage(QOpenGLDebugMessage::createApplicationMessage(QStringLiteral("QOpenGLDebugLogger is logging.")));
        } else {
            qDebug() << "QOpenGLDebugLogger cannot be initialized.";
            delete openglLogger;
        }
    }
 
    // Double check we were given the version we requested
    QSurfaceFormat format = ctx->format();
    QOpenGLFunctions *f = ctx->functions();
    f->initializeOpenGLFunctions();
 
    if (openGLCheckResult->supportsBufferInvalidation()) {
        QOpenGLContext *ctx = QOpenGLContext::currentContext();
        g_glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)ctx->getProcAddress("glInvalidateBufferData");
    }
 
    QFile log(QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/krita-opengl.txt");
    if (log.open(QFile::WriteOnly)) {
        QString vendor((const char*)f->glGetString(GL_VENDOR));
        log.write(vendor.toLatin1());
        log.write(", ");
        log.write(openGLCheckResult->rendererString().toLatin1());
        log.write(", ");
        QString version((const char*)f->glGetString(GL_VERSION));
        log.write(version.toLatin1());
        log.close();
    } else {
        qWarning() << "Could not open" << log.fileName() << "for writing:" << log.errorString();
    }
}

References dbgUI, and initialize().

needsFenceWorkaround()

bool KisOpenGL::needsFenceWorkaround ( )

static

Returns true if we have a driver that has bugged support to sync objects (a fence) and false otherwise.

Definition at line 425 of file kis_opengl.cpp.

{
    initialize();
    return g_needsFenceWorkaround;
}

References initialize().

selectSurfaceConfig()

KisOpenGL::RendererConfig KisOpenGL::selectSurfaceConfig ( KisOpenGL::OpenGLRenderer preferredRenderer, KisConfig::RootSurfaceFormat preferredRootSurfaceFormat, KisConfig::CanvasSurfaceBitDepthMode preferredCanvasSurfaceBitMode, bool enableDebug )

static

On Windows we always prefer Angle, not what Qt suggests us

Definition at line 910 of file kis_opengl.cpp.

{
    QVector<KLocalizedString> warningMessages;
 
    using Info = boost::optional<KisOpenGLModeProber::Result>;
 
    QHash<OpenGLRenderer, Info> renderersToTest;
#ifndef Q_OS_ANDROID
    renderersToTest.insert(RendererDesktopGL, Info());
#endif
    renderersToTest.insert(RendererOpenGLES, Info());
 
#ifdef Q_OS_WIN
    renderersToTest.insert(RendererSoftware, Info());
#endif
 
    auto makeDefaultSurfaceFormatPair = [] () -> std::pair<KisSurfaceColorSpaceWrapper, int> {
        return {KisSurfaceColorSpaceWrapper::DefaultColorSpace, 8};
    };
 
#if defined HAVE_HDR
    std::vector<std::pair<KisSurfaceColorSpaceWrapper, int>> formatSymbolPairs(
        {
            // TODO: check if we can use real sRGB space here
            {KisSurfaceColorSpaceWrapper::DefaultColorSpace, 8},
            {KisSurfaceColorSpaceWrapper::scRGBColorSpace, 16},
            {KisSurfaceColorSpaceWrapper::bt2020PQColorSpace, 10}
        });
#elif KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
    std::vector<std::pair<KisSurfaceColorSpaceWrapper, int>> formatSymbolPairs(
        {
            {KisSurfaceColorSpaceWrapper::DefaultColorSpace, 8},
            {KisSurfaceColorSpaceWrapper::DefaultColorSpace, 10},
        });
#else
    std::vector<std::pair<KisSurfaceColorSpaceWrapper, int>> formatSymbolPairs(
        {
            {KisSurfaceColorSpaceWrapper::DefaultColorSpace, 8},
        });
#endif
 
    bool shouldInhibitCompatibilityProfile = false;
    KisOpenGL::RendererConfig defaultConfig = generateSurfaceConfig(KisOpenGL::RendererAuto,
                                                                    makeDefaultSurfaceFormatPair(),
                                                                    false,
                                                                    shouldInhibitCompatibilityProfile);
    Info info = KisOpenGLModeProber::instance()->probeFormat(defaultConfig);
 
#ifndef Q_OS_MACOS
    // When RendererAuto is active, Qt may perform insane things internally,
    // e.g. switch from OpenGL to OpenGLES automatically. And the presence of
    // the compatibility profile flag will cause the context creation process
    // to fail.
    //
    // So, here we request an explicit API again to avoid Qt making decisions
    // for us.
 
    if (!info) {
        dbgOpenGL << "Failed to probe default Qt's openGL format.. Trying DesktopGL with compatibility enabled...";
        shouldInhibitCompatibilityProfile = false;
        defaultConfig = generateSurfaceConfig(KisOpenGL::RendererDesktopGL,
                                              makeDefaultSurfaceFormatPair(),
                                              false,
                                              shouldInhibitCompatibilityProfile);
        info = KisOpenGLModeProber::instance()->probeFormat(defaultConfig);
    }
 
    if (!info) {
        dbgOpenGL << "Failed again.. Trying DesktopGL with compatibility disabled...";
        shouldInhibitCompatibilityProfile = true;
        defaultConfig = generateSurfaceConfig(KisOpenGL::RendererDesktopGL,
                                              makeDefaultSurfaceFormatPair(),
                                              false,
                                              shouldInhibitCompatibilityProfile);
        info = KisOpenGLModeProber::instance()->probeFormat(defaultConfig);
    }
 
    if (!info) {
        dbgOpenGL << "Failed again.. Trying OpenGLES...";
        shouldInhibitCompatibilityProfile = false;
        defaultConfig = generateSurfaceConfig(KisOpenGL::RendererOpenGLES,
                                              makeDefaultSurfaceFormatPair(),
                                              false,
                                              true);
        info = KisOpenGLModeProber::instance()->probeFormat(defaultConfig);
    }
 
#endif /* Q_OS_MACOS */
 
#ifdef Q_OS_WIN
    if (!info) {
        // try software rasterizer (WARP)
        defaultConfig = generateSurfaceConfig(KisOpenGL::RendererSoftware,
                                              makeDefaultSurfaceFormatPair(),
                                              false,
                                              shouldInhibitCompatibilityProfile);
        info = KisOpenGLModeProber::instance()->probeFormat(defaultConfig);
 
        if (!info) {
            renderersToTest.remove(RendererSoftware);
        }
    }
#endif
 
    if (!info) {
        dbgOpenGL << "Failed to probe default openGL format! No openGL support will be available in Krita";
        return KisOpenGL::RendererConfig();
    }
 
    const OpenGLRenderer defaultRenderer = getRendererFromProbeResult(*info);
 
#ifdef Q_OS_WIN
    const OpenGLRenderer preferredAutoRenderer = RendererOpenGLES;
#else
    const OpenGLRenderer preferredAutoRenderer = defaultRenderer;
#endif
 
    OpenGLRenderers supportedRenderers = RendererNone;
 
    FormatPositionLess compareOp;
    compareOp.setPreferredRendererByQt(preferredAutoRenderer);
 
#ifdef HAVE_HDR
    compareOp.setPreferredColorSpace(
        preferredRootSurfaceFormat == KisConfig::BT709_G22 ? KisSurfaceColorSpaceWrapper::sRGBColorSpace :
        preferredRootSurfaceFormat == KisConfig::BT709_G10 ? KisSurfaceColorSpaceWrapper::scRGBColorSpace :
        KisSurfaceColorSpaceWrapper::bt2020PQColorSpace);
#else
    Q_UNUSED(preferredRootSurfaceFormat);
    compareOp.setPreferredColorSpace(KisSurfaceColorSpaceWrapper::sRGBColorSpace);
#endif
 
#ifdef Q_OS_WIN
    compareOp.setPreferredRendererByHDR(KisOpenGL::RendererOpenGLES);
#endif
    compareOp.setPreferredRendererByUser(preferredRenderer);
    compareOp.setOpenGLESBlacklisted(false); // We cannot blacklist ES drivers atm
 
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
    // 10-bit is the default, 8-bit is set explicitly by the user
    compareOp.setUserPreferredBitDepth(preferredCanvasSurfaceBitMode == KisConfig::CanvasSurfaceBitDepthMode::Depth8Bit ? 8 : 10);
#else
    Q_UNUSED(preferredCanvasSurfaceBitMode)
#endif
 
    renderersToTest[defaultRenderer] = info;
 
    for (auto it = renderersToTest.begin(); it != renderersToTest.end(); ++it) {
        Info info = it.value();
 
        if (!info) {
            const RendererConfig config = generateSurfaceConfig(it.key(), makeDefaultSurfaceFormatPair(), false, shouldInhibitCompatibilityProfile);
            dbgOpenGL << "Probing" << it.key() << "from default:" << config.format << config.angleRenderer
                      << config.rendererId();
            info = KisOpenGLModeProber::instance()->probeFormat(config);
            *it = info;
        } else {
            dbgOpenGL << "Already probed:" << it.key();
        }
 
        compareOp.setOpenGLBlacklisted(
            !info ||
            isOpenGLRendererBlacklisted(info->rendererString(),
                                        info->driverVersionString(),
                                        &warningMessages));
 
        if (info) {
            dbgOpenGL << "Result:" << info->rendererString() << info->driverVersionString()
                      << info->isSupportedVersion();
        }
 
        if (info) {
            g_detectedRenderers << std::make_tuple(info->rendererString(),
                                                   info->driverVersionString(),
                                                   info->isSupportedVersion());
        }
 
        if (info && info->isSupportedVersion()) {
            supportedRenderers |= it.key();
        }
    }
 
    OpenGLRenderer preferredByQt = preferredAutoRenderer;
 
    if (preferredByQt == RendererDesktopGL &&
        supportedRenderers & RendererDesktopGL &&
        compareOp.isOpenGLBlacklisted()) {
 
        preferredByQt = RendererOpenGLES;
 
    } else if (preferredByQt == RendererOpenGLES &&
               supportedRenderers & RendererOpenGLES &&
               compareOp.isOpenGLESBlacklisted()) {
 
        preferredByQt = RendererDesktopGL;
    }
 
    QVector<RendererConfig> preferredConfigs;
    for (auto it = renderersToTest.begin(); it != renderersToTest.end(); ++it) {
        // if default mode of the renderer doesn't work, then custom won't either
        if (!it.value()) continue;
 
        Q_FOREACH (const auto &formatPair, formatSymbolPairs) {
            preferredConfigs << generateSurfaceConfig(it.key(), formatPair, enableDebug, shouldInhibitCompatibilityProfile);
        }
    }
 
    std::stable_sort(preferredConfigs.begin(), preferredConfigs.end(), compareOp);
 
    dbgDetection() << "Supported renderers:" << supportedRenderers;
 
    dbgDetection() << "Surface format preference list:";
    Q_FOREACH (const KisOpenGL::RendererConfig &config, preferredConfigs) {
        dbgDetection() << "*" << config.format;
        dbgDetection() << "   " << config.rendererId();
    }
 
    KisOpenGL::RendererConfig resultConfig = defaultConfig;
 
    if (preferredRenderer != RendererNone) {
        Q_FOREACH (const KisOpenGL::RendererConfig &config, preferredConfigs) {
            dbgDetection() <<"Probing format..." << config.format.colorSpace() << config.rendererId();
            Info info = KisOpenGLModeProber::instance()->probeFormat(config);
 
            if (info && info->isSupportedVersion()) {
 
#ifdef Q_OS_WIN
                // HACK: Block ANGLE with Direct3D9
                //       Direct3D9 does not give OpenGL ES 3.0
                //       Some versions of ANGLE returns OpenGL version 3.0 incorrectly
 
                if (info->isUsingAngle() &&
                        info->rendererString().contains("Direct3D9", Qt::CaseInsensitive)) {
 
                    dbgDetection() << "Skipping Direct3D 9 Angle implementation, it shouldn't have happened.";
 
                    continue;
                }
#endif
 
                dbgDetection() << "Found format:" << config.format;
                dbgDetection() << "   " << config.rendererId();
 
                resultConfig = config;
                break;
            }
        }
 
        {
            const bool colorSpaceIsCorrect =
                    KisOpenGLModeProber::fuzzyCompareColorSpaces(compareOp.preferredColorSpace(),
                                                                 KisSurfaceColorSpaceWrapper::fromQtColorSpace(resultConfig.format.colorSpace()));
 
            const bool rendererIsCorrect =
                    compareOp.preferredRendererByUser() == KisOpenGL::RendererAuto ||
                    compareOp.preferredRendererByUser() == resultConfig.rendererId();
 
            if (!rendererIsCorrect && colorSpaceIsCorrect) {
                warningMessages << ki18n("Preferred renderer doesn't support requested surface format. Another renderer has been selected.");
            } else if (!colorSpaceIsCorrect) {
                warningMessages << ki18n("Preferred output format is not supported by available renderers");
            }
 
        }
    } else {
        resultConfig.format = QSurfaceFormat();
        resultConfig.angleRenderer = AngleRendererDefault;
    }
 
    overrideSupportedRenderers(supportedRenderers, preferredByQt);
    overrideOpenGLWarningString(warningMessages);
 
    return resultConfig;
}

References KisOpenGL::RendererConfig::angleRenderer, AngleRendererDefault, KisSurfaceColorSpaceWrapper::bt2020PQColorSpace, KisConfig::BT709_G10, KisConfig::BT709_G22, dbgDetection, dbgOpenGL, KisSurfaceColorSpaceWrapper::DefaultColorSpace, KisConfig::Depth8Bit, KisOpenGL::RendererConfig::format, KisSurfaceColorSpaceWrapper::fromQtColorSpace(), KisOpenGLModeProber::fuzzyCompareColorSpaces(), KisOpenGLModeProber::instance(), KisOpenGLModeProber::probeFormat(), RendererAuto, RendererDesktopGL, KisOpenGL::RendererConfig::rendererId(), RendererNone, RendererOpenGLES, RendererSoftware, KisSurfaceColorSpaceWrapper::scRGBColorSpace, and KisSurfaceColorSpaceWrapper::sRGBColorSpace.

setDebugSynchronous()

void KisOpenGL::setDebugSynchronous ( bool value )

static

Definition at line 436 of file kis_opengl.cpp.

{
    g_isDebugSynchronous = value;
}

References value().

setDefaultSurfaceConfig()

void KisOpenGL::setDefaultSurfaceConfig ( const RendererConfig & config )

static

Definition at line 1191 of file kis_opengl.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(!g_sanityDefaultFormatIsSet);
 
    g_sanityDefaultFormatIsSet = true;
    QSurfaceFormat::setDefaultFormat(config.format);
 
    if (config.format.renderableType() == QSurfaceFormat::OpenGLES) {
        QCoreApplication::setAttribute(Qt::AA_UseOpenGLES, true);
#ifdef Q_OS_WIN
        if (!qEnvironmentVariableIsSet("QT_ANGLE_PLATFORM")) {
            // Force ANGLE to use Direct3D11. D3D9 doesn't support OpenGL ES 3 and WARP
            //  might get weird crashes atm.
            qputenv("QT_ANGLE_PLATFORM", KisOpenGLModeProber::angleRendererToString(config.angleRenderer).toLatin1());
        }
#endif
    } else if (config.format.renderableType() == QSurfaceFormat::OpenGL) {
        QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL, true);
    }
}

References KisOpenGL::RendererConfig::angleRenderer, KisOpenGLModeProber::angleRendererToString(), KisOpenGL::RendererConfig::format, and KIS_SAFE_ASSERT_RECOVER_NOOP.

setUserPreferredOpenGLRendererConfig()

void KisOpenGL::setUserPreferredOpenGLRendererConfig ( KisOpenGL::OpenGLRenderer renderer )

static

Definition at line 469 of file kis_opengl.cpp.

{
    const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
    QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
    kritarc.setValue("OpenGLRenderer", KisOpenGL::convertOpenGLRendererToConfig(renderer));
}

References convertOpenGLRendererToConfig().

shouldUseTextureBuffers()

bool KisOpenGL::shouldUseTextureBuffers ( bool userPreference )

static

Definition at line 400 of file kis_opengl.cpp.

{
    initialize();
    return !g_forceDisableTextureBuffers && userPreference;
}

References initialize().

supportsBufferMapping()

bool KisOpenGL::supportsBufferMapping ( )

static

Definition at line 388 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult && openGLCheckResult->supportsBufferMapping();
}

References initialize().

supportsFenceSync()

bool KisOpenGL::supportsFenceSync ( )

static

supportsFilter

Returns

True if OpenGL provides fence sync methods.

Definition at line 382 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult && openGLCheckResult->supportsFenceSync();
}

References initialize().

supportsLoD()

bool KisOpenGL::supportsLoD ( )

static

Definition at line 358 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult && openGLCheckResult->supportsLoD();
}

References initialize().

supportsVAO()

bool KisOpenGL::supportsVAO ( )

static

Definition at line 370 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult && openGLCheckResult->supportsVAO();
}

References initialize().

testingInitializeDefaultSurfaceFormat()

void KisOpenGL::testingInitializeDefaultSurfaceFormat ( )

static

Definition at line 431 of file kis_opengl.cpp.

{
    setDefaultSurfaceConfig(selectSurfaceConfig(KisOpenGL::RendererAuto, KisConfig::BT709_G22, KisConfig::CanvasSurfaceBitDepthMode::DepthAuto, false));
}

References KisConfig::BT709_G22, KisConfig::DepthAuto, RendererAuto, selectSurfaceConfig(), and setDefaultSurfaceConfig().

useFBOForToolOutlineRendering()

bool KisOpenGL::useFBOForToolOutlineRendering ( )

static

supportsRenderToFBO

Returns

True if OpenGL can render to FBO, used currently for rendering cursor with image overlay fx.

Definition at line 413 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult && openGLCheckResult->supportsFBO();
}

References initialize().

useTextureBufferInvalidation()

bool KisOpenGL::useTextureBufferInvalidation ( )

static

Definition at line 406 of file kis_opengl.cpp.

{
    initialize();
    return g_useBufferInvalidation &&
        openGLCheckResult && openGLCheckResult->supportsBufferInvalidation();
}

References initialize().

xcbGlProviderProtocol()

std::optional< KisOpenGL::XcbGLProviderProtocol > KisOpenGL::xcbGlProviderProtocol ( )

static

Definition at line 419 of file kis_opengl.cpp.

{
    initialize();
    return openGLCheckResult ? openGLCheckResult->xcbGlProviderProtocol() : std::nullopt;
}

References initialize().

---

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

• libs/ui/opengl/kis_opengl.h
• libs/ui/opengl/kis_opengl.cpp