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 490 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 474 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 345 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 392 of file kis_opengl.cpp.

{
    initialize();
    return g_forceDisableTextureBuffers;
}

References initialize().

getCurrentOpenGLRenderer()

KisOpenGL::OpenGLRenderer KisOpenGL::getCurrentOpenGLRenderer ( )

static

Definition at line 444 of file kis_opengl.cpp.

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

References RendererAuto.

getDebugText()

const QString & KisOpenGL::getDebugText ( )

static

Definition at line 331 of file kis_opengl.cpp.

{
    initialize();
    return g_debugText;
}

References initialize().

getOpenGLWarnings()

QStringList KisOpenGL::getOpenGLWarnings ( )

static

Definition at line 337 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 450 of file kis_opengl.cpp.

{
    return g_rendererPreferredByQt;
}

getSupportedOpenGLRenderers()

KisOpenGL::OpenGLRenderers KisOpenGL::getSupportedOpenGLRenderers ( )

static

Definition at line 455 of file kis_opengl.cpp.

{
    return g_supportedRenderers;
}

getUserPreferredOpenGLRendererConfig()

KisOpenGL::OpenGLRenderer KisOpenGL::getUserPreferredOpenGLRendererConfig ( )

static

Definition at line 460 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 439 of file kis_opengl.cpp.

{
    g_glInvalidateBufferData(buffer);
}

hasOpenGL()

bool KisOpenGL::hasOpenGL ( )

static

Check for OpenGL.

Definition at line 1210 of file kis_opengl.cpp.

{
    return openGLCheckResult->isSupportedVersion();
}

hasOpenGL3()

bool KisOpenGL::hasOpenGL3 ( )

static

Definition at line 362 of file kis_opengl.cpp.

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

References initialize().

hasOpenGLES()

bool KisOpenGL::hasOpenGLES ( )

static

Definition at line 374 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 137 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 282 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 423 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 908 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 434 of file kis_opengl.cpp.

{
    g_isDebugSynchronous = value;
}

References value().

setDefaultSurfaceConfig()

void KisOpenGL::setDefaultSurfaceConfig ( const RendererConfig & config )

static

Definition at line 1189 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 467 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 398 of file kis_opengl.cpp.

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

References initialize().

supportsBufferMapping()

bool KisOpenGL::supportsBufferMapping ( )

static

Definition at line 386 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 380 of file kis_opengl.cpp.

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

References initialize().

supportsLoD()

bool KisOpenGL::supportsLoD ( )

static

Definition at line 356 of file kis_opengl.cpp.

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

References initialize().

supportsVAO()

bool KisOpenGL::supportsVAO ( )

static

Definition at line 368 of file kis_opengl.cpp.

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

References initialize().

testingInitializeDefaultSurfaceFormat()

void KisOpenGL::testingInitializeDefaultSurfaceFormat ( )

static

Definition at line 429 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 411 of file kis_opengl.cpp.

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

References initialize().

useTextureBufferInvalidation()

bool KisOpenGL::useTextureBufferInvalidation ( )

static

Definition at line 404 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 417 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