KisOpenGLModeProber Class Reference

#include <KisOpenGLModeProber.h>

Classes
class	Result

Public Member Functions
	KisOpenGLModeProber ()
boost::optional< Result >	probeFormat (const KisOpenGL::RendererConfig &rendererConfig, bool adjustGlobalState=true)
const KoColorProfile *	rootSurfaceColorProfile () const
QSurfaceFormat	surfaceformatInUse () const
bool	useHDRMode () const
	~KisOpenGLModeProber ()

Static Public Member Functions
static QString	angleRendererToString (KisOpenGL::AngleRenderer renderer)
static bool	fuzzyCompareColorSpaces (const KisSurfaceColorSpaceWrapper &lhs, const KisSurfaceColorSpaceWrapper &rhs)
static void	initSurfaceFormatFromConfig (std::pair< KisSurfaceColorSpaceWrapper, int > rootSurfaceFormat, QSurfaceFormat *format)
static KisOpenGLModeProber *	instance ()
static bool	isFormatHDR (const QSurfaceFormat &format)

Detailed Description

Definition at line 21 of file KisOpenGLModeProber.h.

Constructor & Destructor Documentation

KisOpenGLModeProber()

KisOpenGLModeProber::KisOpenGLModeProber

(

)

Definition at line 23 of file KisOpenGLModeProber.cpp.

{
}

~KisOpenGLModeProber()

KisOpenGLModeProber::~KisOpenGLModeProber

(

)

Definition at line 27 of file KisOpenGLModeProber.cpp.

{
 
}

Member Function Documentation

angleRendererToString()

QString KisOpenGLModeProber::angleRendererToString ( KisOpenGL::AngleRenderer renderer )

static

Definition at line 333 of file KisOpenGLModeProber.cpp.

{
    QString value;
 
    switch (renderer) {
    case KisOpenGL::AngleRendererDefault:
        break;
    case KisOpenGL::AngleRendererD3d9:
        value = "d3d9";
        break;
    case KisOpenGL::AngleRendererD3d11:
        value = "d3d11";
        break;
    case KisOpenGL::AngleRendererD3d11Warp:
        value = "warp";
        break;
    };
 
    return value;
}

References KisOpenGL::AngleRendererD3d11, KisOpenGL::AngleRendererD3d11Warp, KisOpenGL::AngleRendererD3d9, KisOpenGL::AngleRendererDefault, and value().

fuzzyCompareColorSpaces()

bool KisOpenGLModeProber::fuzzyCompareColorSpaces ( const KisSurfaceColorSpaceWrapper & lhs, const KisSurfaceColorSpaceWrapper & rhs )

static

Definition at line 235 of file KisOpenGLModeProber.cpp.

{
    return lhs == rhs ||
        ((lhs == KisSurfaceColorSpaceWrapper::DefaultColorSpace ||
          lhs == KisSurfaceColorSpaceWrapper::sRGBColorSpace) &&
         (rhs == KisSurfaceColorSpaceWrapper::DefaultColorSpace ||
          rhs == KisSurfaceColorSpaceWrapper::sRGBColorSpace));
}

References KisSurfaceColorSpaceWrapper::DefaultColorSpace, and KisSurfaceColorSpaceWrapper::sRGBColorSpace.

initSurfaceFormatFromConfig()

void KisOpenGLModeProber::initSurfaceFormatFromConfig ( std::pair< KisSurfaceColorSpaceWrapper, int > rootSurfaceFormat, QSurfaceFormat * format )

static

In Wayland's HDR we don't set the mode on the root surface, we should only select bit-width.

Definition at line 244 of file KisOpenGLModeProber.cpp.

{
#ifdef HAVE_HDR
    if (rootSurfaceFormat.first == KisSurfaceColorSpaceWrapper::bt2020PQColorSpace) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(rootSurfaceFormat.second == 10);
        format->setRedBufferSize(10);
        format->setGreenBufferSize(10);
        format->setBlueBufferSize(10);
        format->setAlphaBufferSize(2);
        format->setColorSpace(KisSurfaceColorSpaceWrapper(KisSurfaceColorSpaceWrapper::bt2020PQColorSpace));
    } else if (rootSurfaceFormat.first == KisSurfaceColorSpaceWrapper::scRGBColorSpace) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(rootSurfaceFormat.second == 16);
        format->setRedBufferSize(16);
        format->setGreenBufferSize(16);
        format->setBlueBufferSize(16);
        format->setAlphaBufferSize(16);
        format->setColorSpace(KisSurfaceColorSpaceWrapper(KisSurfaceColorSpaceWrapper::scRGBColorSpace));
    } else {
        KIS_SAFE_ASSERT_RECOVER_NOOP(rootSurfaceFormat.second == 8);
        format->setRedBufferSize(8);
        format->setGreenBufferSize(8);
        format->setBlueBufferSize(8);
        format->setAlphaBufferSize(8);
        // TODO: check if we can use real sRGB space here
        format->setColorSpace(KisSurfaceColorSpaceWrapper());
    }
#else
    if (rootSurfaceFormat.first == KisSurfaceColorSpaceWrapper::bt2020PQColorSpace) {
        qWarning() << "WARNING: Bt.2020 PQ surface type is not supported by this build of Krita";
        rootSurfaceFormat.first = KisSurfaceColorSpaceWrapper::DefaultColorSpace;
    } else if (rootSurfaceFormat.first == KisSurfaceColorSpaceWrapper::scRGBColorSpace) {
        qWarning() << "WARNING: scRGB surface type is not supported by this build of Krita";
        rootSurfaceFormat.first = KisSurfaceColorSpaceWrapper::DefaultColorSpace;
    } else {
        KIS_SAFE_ASSERT_RECOVER_NOOP(rootSurfaceFormat.first == KisSurfaceColorSpaceWrapper::DefaultColorSpace);
        KIS_SAFE_ASSERT_RECOVER_NOOP(rootSurfaceFormat.second == 8 || rootSurfaceFormat.second == 10);
 
        if (rootSurfaceFormat.second == 10) {
            format->setRedBufferSize(10);
            format->setGreenBufferSize(10);
            format->setBlueBufferSize(10);
            format->setAlphaBufferSize(2);
            // TODO: check if we can use real sRGB space here
            format->setColorSpace(KisSurfaceColorSpaceWrapper());
        } else {
            format->setRedBufferSize(8);
            format->setGreenBufferSize(8);
            format->setBlueBufferSize(8);
            format->setAlphaBufferSize(8);
            // TODO: check if we can use real sRGB space here
            format->setColorSpace(KisSurfaceColorSpaceWrapper());
        }
    }
#endif
}

References KisSurfaceColorSpaceWrapper::bt2020PQColorSpace, KisSurfaceColorSpaceWrapper::DefaultColorSpace, KIS_SAFE_ASSERT_RECOVER_NOOP, and KisSurfaceColorSpaceWrapper::scRGBColorSpace.

instance()

KisOpenGLModeProber * KisOpenGLModeProber::instance ( )

static

Definition at line 32 of file KisOpenGLModeProber.cpp.

{
    return s_instance;
}

isFormatHDR()

bool KisOpenGLModeProber::isFormatHDR ( const QSurfaceFormat & format )

static

Definition at line 308 of file KisOpenGLModeProber.cpp.

{
#ifdef HAVE_HDR
 
    bool isBt2020PQ =
        format.colorSpace() == KisSurfaceColorSpaceWrapper::makeBt2020PQColorSpace() &&
        format.redBufferSize() == 10 &&
        format.greenBufferSize() == 10 &&
        format.blueBufferSize() == 10 &&
        format.alphaBufferSize() == 2;
 
    bool isBt709G10 =
        format.colorSpace() == KisSurfaceColorSpaceWrapper::makeSCRGBColorSpace() &&
        format.redBufferSize() == 16 &&
        format.greenBufferSize() == 16 &&
        format.blueBufferSize() == 16 &&
        format.alphaBufferSize() == 16;
 
    return isBt2020PQ || isBt709G10;
#else
    Q_UNUSED(format);
    return false;
#endif
}

References KisSurfaceColorSpaceWrapper::makeBt2020PQColorSpace(), and KisSurfaceColorSpaceWrapper::makeSCRGBColorSpace().

probeFormat()

boost::optional< KisOpenGLModeProber::Result > KisOpenGLModeProber::probeFormat	(	const KisOpenGL::RendererConfig &	rendererConfig,
		bool	adjustGlobalState = true )

Definition at line 137 of file KisOpenGLModeProber.cpp.

{
    const QSurfaceFormat &format = rendererConfig.format;
 
    dbgOpenGL << "Probing format" << rendererConfig.rendererId() << rendererConfig.angleRenderer
              << rendererConfig.format;
 
    QScopedPointer<AppAttributeSetter> sharedContextSetter;
    QScopedPointer<AppAttributeSetter> glSetter;
    QScopedPointer<AppAttributeSetter> glesSetter;
    QScopedPointer<SurfaceFormatSetter> formatSetter;
    QScopedPointer<EnvironmentSetter> rendererSetter;
    QScopedPointer<EnvironmentSetter> portalSetter;
    QScopedPointer<QGuiApplication> application;
 
    int argc = 1;
    QByteArray probeAppName("krita");
    char *argv = probeAppName.data();
 
 
    if (adjustGlobalState) {
        sharedContextSetter.reset(new AppAttributeSetter(Qt::AA_ShareOpenGLContexts, false));
 
        if (format.renderableType() != QSurfaceFormat::DefaultRenderableType) {
            glSetter.reset(new AppAttributeSetter(Qt::AA_UseDesktopOpenGL, format.renderableType() != QSurfaceFormat::OpenGLES));
            glesSetter.reset(new AppAttributeSetter(Qt::AA_UseOpenGLES, format.renderableType() == QSurfaceFormat::OpenGLES));
        }
 
        if (!qEnvironmentVariableIsSet("QT_ANGLE_PLATFORM")) {
            rendererSetter.reset(new EnvironmentSetter(QLatin1String("QT_ANGLE_PLATFORM"), angleRendererToString(rendererConfig.angleRenderer)));
        }
        portalSetter.reset(new EnvironmentSetter(QLatin1String("QT_NO_XDG_DESKTOP_PORTAL"), QLatin1String("1")));
        formatSetter.reset(new SurfaceFormatSetter(format));
 
        // Disable this workaround for plasma (BUG:408015), because it causes 
        // a crash on Windows with Qt 5.15.7
        const bool runningInKDE =  qEnvironmentVariableIsSet("KDE_FULL_SESSION");
        const bool isInAppimage = qEnvironmentVariableIsSet("APPIMAGE");
 
        if (runningInKDE && !isInAppimage) {
            QGuiApplication::setDesktopSettingsAware(false);
        }
 
        application.reset(new QGuiApplication(argc, &argv));
 
        if (runningInKDE && !isInAppimage) {
            QGuiApplication::setDesktopSettingsAware(true);
        }
 
    }
 
    QWindow surface;
    surface.setFormat(format);
    surface.setSurfaceType(QSurface::OpenGLSurface);
    surface.create();
    QOpenGLContext context;
    context.setFormat(format);
 
 
    if (!context.create()) {
        dbgOpenGL << "OpenGL context cannot be created";
        return boost::none;
    }
    if (!context.isValid()) {
        dbgOpenGL << "OpenGL context is not valid while checking Qt's OpenGL status";
        return boost::none;
    }
    if (!context.makeCurrent(&surface)) {
        dbgOpenGL << "OpenGL context cannot be made current";
        return boost::none;
    }
 
    if (!fuzzyCompareColorSpaces(
            KisSurfaceColorSpaceWrapper::fromQtColorSpace(context.format().colorSpace()),
            KisSurfaceColorSpaceWrapper::fromQtColorSpace(format.colorSpace()))) {
 
        dbgOpenGL << "Failed to create an OpenGL context with requested color space. Requested:" << format.colorSpace() << "Actual:" << context.format().colorSpace();
        return boost::none;
    }
 
    if (format.redBufferSize() > 0 && format.greenBufferSize() > 0 && format.blueBufferSize() > 0
        && (context.format().redBufferSize() != format.redBufferSize()
            || context.format().greenBufferSize() != format.greenBufferSize()
            || context.format().blueBufferSize() != format.blueBufferSize())) {
 
        dbgOpenGL << "Failed to create an OpenGL context with requested bit depth. Requested:" << format.redBufferSize()
                  << "Actual:" << context.format().redBufferSize();
        return boost::none;
    }
 
    Result result(context);
 
    dbgOpenGL << "Probe returned" << result.rendererString() << result.driverVersionString() << result.isOpenGLES();
 
    return result;
}

References KisOpenGL::RendererConfig::angleRenderer, angleRendererToString(), dbgOpenGL, KisOpenGLModeProber::Result::driverVersionString(), KisOpenGL::RendererConfig::format, KisSurfaceColorSpaceWrapper::fromQtColorSpace(), fuzzyCompareColorSpaces(), KisOpenGLModeProber::Result::isOpenGLES(), KisOpenGL::RendererConfig::rendererId(), and KisOpenGLModeProber::Result::rendererString().

rootSurfaceColorProfile()

const KoColorProfile * KisOpenGLModeProber::rootSurfaceColorProfile

(

)

const

Definition at line 50 of file KisOpenGLModeProber.cpp.

{
    const KoColorProfile *profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
 
    const auto surfaceColorSpace = 
        KisSurfaceColorSpaceWrapper::fromQtColorSpace(surfaceformatInUse().colorSpace());
    
    if (surfaceColorSpace == KisSurfaceColorSpaceWrapper::sRGBColorSpace) {
        // use the default one!
#ifdef HAVE_HDR
    } else if (surfaceColorSpace == KisSurfaceColorSpaceWrapper::scRGBColorSpace) {
        profile = KoColorSpaceRegistry::instance()->p709G10Profile();
    } else if (surfaceColorSpace == KisSurfaceColorSpaceWrapper::bt2020PQColorSpace) {
        profile = KoColorSpaceRegistry::instance()->p2020PQProfile();
#endif
    }
 
    return profile;
}

References KisSurfaceColorSpaceWrapper::bt2020PQColorSpace, KisSurfaceColorSpaceWrapper::fromQtColorSpace(), KoColorSpaceRegistry::instance(), KoColorSpaceRegistry::p2020PQProfile(), KoColorSpaceRegistry::p709G10Profile(), KoColorSpaceRegistry::p709SRGBProfile(), KisSurfaceColorSpaceWrapper::scRGBColorSpace, KisSurfaceColorSpaceWrapper::sRGBColorSpace, and surfaceformatInUse().

surfaceformatInUse()

QSurfaceFormat KisOpenGLModeProber::surfaceformatInUse

(

)

const

Definition at line 42 of file KisOpenGLModeProber.cpp.

{
    // TODO: use information provided by KisOpenGL instead
    QOpenGLContext *sharedContext = QOpenGLContext::globalShareContext();
    QSurfaceFormat format = sharedContext ? sharedContext->format() : QSurfaceFormat::defaultFormat();
    return format;
}

useHDRMode()

bool KisOpenGLModeProber::useHDRMode

(

)

const

Definition at line 37 of file KisOpenGLModeProber.cpp.

{
    return isFormatHDR(QSurfaceFormat::defaultFormat());
}

References isFormatHDR().

---

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

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