KisOpenGLShaderLoader Class Reference

#include <kis_opengl_shader_loader.h>

Public Member Functions
KisShaderProgram *	loadCheckerShader ()
KisShaderProgram *	loadDisplayShader (QSharedPointer< KisDisplayFilter > displayFilter, bool useHiQualityFiltering)
KisShaderProgram *	loadSolidColorShader ()

Private Member Functions
KisShaderProgram *	loadShader (QString vertPath, QString fragPath, QByteArray vertHeader, QByteArray fragHeader)

Detailed Description

A utility class for loading various shaders we use in Krita. It provides specific methods for shaders that pick the correct vertex and fragment files depending on the availability of OpenGL3. Additionally, it provides a generic shader loading method to prevent duplication.

Definition at line 71 of file kis_opengl_shader_loader.h.

Member Function Documentation

loadCheckerShader()

KisShaderProgram * KisOpenGLShaderLoader::loadCheckerShader

(

)

Specific checker shader loading function. It picks the appropriate shader files depending on the availability of OpenGL3 on the target machine.

Definition at line 175 of file kis_opengl_shader_loader.cpp.

{
    QString vertPath, fragPath;
    // Select appropriate shader files
    if (KisOpenGL::supportsLoD()) {
        vertPath = "matrix_transform.vert";
        fragPath = "simple_texture.frag";
    } else {
        vertPath = "matrix_transform_legacy.vert";
        fragPath = "simple_texture_legacy.frag";
    }
 
    KisShaderProgram *shader = loadShader(vertPath, fragPath, QByteArray(), QByteArray());
 
    return shader;
}

References loadShader(), and KisOpenGL::supportsLoD().

loadDisplayShader()

KisShaderProgram * KisOpenGLShaderLoader::loadDisplayShader	(	QSharedPointer< KisDisplayFilter >	displayFilter,
		bool	useHiQualityFiltering )

Specific display shader loading function. It adds the appropriate extra code to the fragment shader depending on what is available on the target machine. Additionally, it picks the appropriate shader files depending on the availability of OpenGL3.

Definition at line 134 of file kis_opengl_shader_loader.cpp.

{
    QByteArray fragHeader;
 
    if (KisOpenGL::supportsLoD()) {
        fragHeader.append("#define DIRECT_LOD_FETCH\n");
        if (useHiQualityFiltering) {
            fragHeader.append("#define HIGHQ_SCALING\n");
        }
    }
 
    // If we have an OCIO display filter and it contains a function we add
    // it to our shader header which will sit on top of the fragment code.
    bool haveDisplayFilter = displayFilter && !displayFilter->program().isEmpty();
    if (haveDisplayFilter) {
        fragHeader.append("#define USE_OCIO\n");
#ifdef HAVE_OCIO_V2
        fragHeader.append("#define USE_OCIO_V2\n");
#endif
        fragHeader.append(displayFilter->program().toLatin1());
    }
 
    QString vertPath, fragPath;
    // Select appropriate shader files
    if (KisOpenGL::supportsLoD()) {
        vertPath = "matrix_transform.vert";
        fragPath = "highq_downscale.frag";
    } else {
        vertPath = "matrix_transform_legacy.vert";
        fragPath = "simple_texture_legacy.frag";
    }
 
    KisShaderProgram *shader = loadShader(vertPath, fragPath, QByteArray(), fragHeader);
 
    return shader;
}

References loadShader(), and KisOpenGL::supportsLoD().

loadShader()

KisShaderProgram * KisOpenGLShaderLoader::loadShader ( QString vertPath, QString fragPath, QByteArray vertHeader, QByteArray fragHeader )

private

Generic shader loading function that will compile a shader program given a vertex shader and fragment shader resource path. Extra code can be prepended to each shader respectively using the header parameters.

Parameters

vertPath	Resource path to a vertex shader
fragPath	Resource path to a fragment shader
vertHeader	Extra code which will be prepended to the vertex shader
fragHeader	Extra code which will be prepended to the fragment shader

Definition at line 44 of file kis_opengl_shader_loader.cpp.

{
    bool result;
 
    KisShaderProgram *shader = new KisShaderProgram();
 
    // Load vertex shader
    QByteArray vertSource;
 
    if (KisOpenGL::hasOpenGLES()) {
        vertSource.append("#version 300 es\n");
    } else {
#ifdef Q_OS_MACOS
        vertSource.append(KisOpenGL::hasOpenGL3() ? "#version 150 core\n" : "#version 120\n");
        vertSource.append("#define texture2D texture\n");
        vertSource.append("#define texture3D texture\n");
#else
        vertSource.append(KisOpenGL::supportsLoD() ? "#version 130\n" : "#version 120\n");
#endif
    }
    vertSource.append(vertHeader);
    QFile vertexShaderFile(":/" + vertPath);
    vertexShaderFile.open(QIODevice::ReadOnly);
    vertSource.append(vertexShaderFile.readAll());
 
    result = shader->addShaderFromSourceCode(QOpenGLShader::Vertex, vertSource);
    if (!result)
        throw ShaderLoaderException(QString("%1: %2 - Cause: %3").arg("Failed to add vertex shader source from file", vertPath, shader->log()));
 
    // Load fragment shader
    QByteArray fragSource;
 
    if (KisOpenGL::hasOpenGLES()) {
        fragSource.append("#version 300 es\n");
        if (KisOpenGL::supportsLoD()) {
            fragSource.append("#extension GL_EXT_shader_texture_lod : enable\n");
        }
        fragSource.append(
            "precision mediump float;\n"
            "precision mediump sampler3D;\n");
 
        // OpenColorIO doesn't support OpenGL ES.
        fragSource.append("#define texture2D texture\n");
        fragSource.append("#define texture3D texture\n");
        if (KisOpenGL::supportsLoD()) {
            fragSource.append(
                "#if __VERSION__ < 300\n"
                "#define textureLod texture2DLodEXT\n"
                "#endif\n"
            );
        }
    } else {
#ifdef Q_OS_MACOS
        fragSource.append(KisOpenGL::hasOpenGL3() ? "#version 150 core\n" : "#version 120\n");
        fragSource.append("#define texture2D texture\n");
        fragSource.append("#define texture3D texture\n");
#else
        fragSource.append(KisOpenGL::supportsLoD() ? "#version 130\n" : "#version 120\n");
#endif
    }
    fragSource.append(fragHeader);
    QFile fragmentShaderFile(":/" + fragPath);
    fragmentShaderFile.open(QIODevice::ReadOnly);
    fragSource.append(fragmentShaderFile.readAll());
 
    result = shader->addShaderFromSourceCode(QOpenGLShader::Fragment, fragSource);
    if (!result)
        throw ShaderLoaderException(QString("%1: %2 - Cause: %3").arg("Failed to add fragment shader source from file", fragPath, shader->log()));
 
    // Bind attributes
    shader->bindAttributeLocation("a_vertexPosition", PROGRAM_VERTEX_ATTRIBUTE);
    shader->bindAttributeLocation("a_textureCoordinate", PROGRAM_TEXCOORD_ATTRIBUTE);
 
    // Link
    result = shader->link();
    if (!result)
        throw ShaderLoaderException(QString("Failed to link shader: ").append(vertPath));
 
    Q_ASSERT(shader->isLinked());
 
    return shader;
}

References KisOpenGL::hasOpenGL3(), KisOpenGL::hasOpenGLES(), PROGRAM_TEXCOORD_ATTRIBUTE, PROGRAM_VERTEX_ATTRIBUTE, and KisOpenGL::supportsLoD().

loadSolidColorShader()

KisShaderProgram * KisOpenGLShaderLoader::loadSolidColorShader

(

)

Specific uniform shader loading function. It picks the appropriate shader files depending on the availability of OpenGL3 on the target machine.

Definition at line 196 of file kis_opengl_shader_loader.cpp.

{
    QString vertPath, fragPath;
    // Select appropriate shader files
    if (KisOpenGL::supportsLoD()) {
        vertPath = "solid_color.vert";
        fragPath = "solid_color.frag";
    } else {
        vertPath = "solid_color_legacy.vert";
        fragPath = "solid_color_legacy.frag";
    }
 
    KisShaderProgram *shader = loadShader(vertPath, fragPath, QByteArray(), QByteArray());
 
    return shader;
}

References loadShader(), and KisOpenGL::supportsLoD().

---

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

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