#include <ocio_display_filter_vfx2020.h>

Inheritance diagram for OcioDisplayFilter:

Public Member Functions
void	approximateForwardTransformation (quint8 *pixels, quint32 numPixels) override

void	approximateForwardTransformation (quint8 *pixels, quint32 numPixels) override

void	approximateInverseTransformation (quint8 *pixels, quint32 numPixels) override

void	approximateInverseTransformation (quint8 *pixels, quint32 numPixels) override

KisExposureGammaCorrectionInterface *	correctionInterface () const override

KisExposureGammaCorrectionInterface *	correctionInterface () const override

void	filter (quint8 *pixels, quint32 numPixels) override

void	filter (quint8 *pixels, quint32 numPixels) override

bool	lockCurrentColorVisualRepresentation () const override

bool	lockCurrentColorVisualRepresentation () const override

	OcioDisplayFilter (KisExposureGammaCorrectionInterface interface, QObject parent=0)

	OcioDisplayFilter (KisExposureGammaCorrectionInterface interface, QObject parent=0)

virtual QString	program () const override

QString	program () const override

void	setLockCurrentColorVisualRepresentation (bool value)

void	setLockCurrentColorVisualRepresentation (bool value)

void	setupTextures (GLFunctions f, QOpenGLShaderProgram program) const override

void	setupTextures (GLFunctions f, QOpenGLShaderProgram program) const override

void	updateProcessor ()

void	updateProcessor ()

bool	updateShader () override

bool	updateShader () override

template<class F >
bool	updateShaderImpl (F *f)

template<class F >
bool	updateShaderImpl (F *f)

bool	useInternalColorManagement () const override

bool	useInternalColorManagement () const override

	~OcioDisplayFilter ()

	~OcioDisplayFilter ()

Public Member Functions inherited from KisDisplayFilter
	KisDisplayFilter (QObject *parent=0)

Public Attributes
float	blackPoint {0.0}

double	blackPoint

OCIO::ConstConfigRcPtr	config

const char *	displayDevice {nullptr}

float	exposure {0.0}

double	exposure

bool	forceInternalColorManagement {false}

float	gamma {0.0}

double	gamma

const char *	inputColorSpaceName {nullptr}

const char *	look {nullptr}

OCIO_CHANNEL_SWIZZLE	swizzle {RGBA}

const char *	view {nullptr}

float	whitePoint {0.0}

double	whitePoint

Private Attributes
OCIO::ConstProcessorRcPtr	m_forwardApproximationProcessor

OCIO::ConstCPUProcessorRcPtr	m_forwardApproximationProcessorCPU

KisExposureGammaCorrectionInterface *	m_interface {nullptr}

bool	m_lockCurrentColorVisualRepresentation {false}

QVector< float >	m_lut3d

QString	m_lut3dcacheid

GLuint	m_lut3dTexID {0}

std::vector< KisTextureEntry >	m_lut3dTexIDs

std::vector< KisTextureUniform >	m_lut3dUniforms

OCIO::ConstProcessorRcPtr	m_processor

OCIO::ConstCPUProcessorRcPtr	m_processorCPU

QString	m_program

OCIO::ConstProcessorRcPtr	m_reverseApproximationProcessor

OCIO::ConstCPUProcessorRcPtr	m_reverseApproximationProcessorCPU

QString	m_shadercacheid

bool	m_shaderDirty {true}

Detailed Description

Definition at line 30 of file ocio_display_filter_vfx2020.h.

Constructor & Destructor Documentation

◆ OcioDisplayFilter() [1/2]

OcioDisplayFilter::OcioDisplayFilter	(	KisExposureGammaCorrectionInterface *	interface,
		QObject *	parent = 0 )

explicit

Definition at line 39 of file ocio_display_filter_vfx2020.cpp.

    : KisDisplayFilter(parent)
    , m_interface(interface)
{
}

◆ ~OcioDisplayFilter() [1/2]

OcioDisplayFilter::~OcioDisplayFilter ( )

Definition at line 45 of file ocio_display_filter_vfx2020.cpp.

46{

47}

◆ OcioDisplayFilter() [2/2]

OcioDisplayFilter::OcioDisplayFilter	(	KisExposureGammaCorrectionInterface *	interface,
		QObject *	parent = 0 )

explicit

◆ ~OcioDisplayFilter() [2/2]

OcioDisplayFilter::~OcioDisplayFilter ( )

Member Function Documentation

◆ approximateForwardTransformation() [1/2]

void OcioDisplayFilter::approximateForwardTransformation	(	quint8 *	pixels,
		quint32	numPixels )

overridevirtual

Implements KisDisplayFilter.

Definition at line 72 of file ocio_display_filter_vfx2020.cpp.

{
    // processes that data _in_ place
    if (m_forwardApproximationProcessor) {
        OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
        m_forwardApproximationProcessor->apply(img);
    }
}

References m_forwardApproximationProcessor.

◆ approximateForwardTransformation() [2/2]

void OcioDisplayFilter::approximateForwardTransformation	(	quint8 *	pixels,
		quint32	numPixels )

overridevirtual

Implements KisDisplayFilter.

◆ approximateInverseTransformation() [1/2]

void OcioDisplayFilter::approximateInverseTransformation	(	quint8 *	pixels,
		quint32	numPixels )

overridevirtual

Implements KisDisplayFilter.

Definition at line 63 of file ocio_display_filter_vfx2020.cpp.

{
    // processes that data _in_ place
    if (m_reverseApproximationProcessor) {
        OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
        m_reverseApproximationProcessor->apply(img);
    }
}

References m_reverseApproximationProcessor.

◆ approximateInverseTransformation() [2/2]

void OcioDisplayFilter::approximateInverseTransformation	(	quint8 *	pixels,
		quint32	numPixels )

overridevirtual

Implements KisDisplayFilter.

◆ correctionInterface() [1/2]

KisExposureGammaCorrectionInterface * OcioDisplayFilter::correctionInterface ( ) const

overridevirtual

Implements KisDisplayFilter.

Definition at line 49 of file ocio_display_filter_vfx2020.cpp.

{
    return m_interface;
}

References m_interface.

◆ correctionInterface() [2/2]

KisExposureGammaCorrectionInterface * OcioDisplayFilter::correctionInterface ( ) const

overridevirtual

Implements KisDisplayFilter.

◆ filter() [1/2]

void OcioDisplayFilter::filter	(	quint8 *	pixels,
		quint32	numPixels )

overridevirtual

Implements KisDisplayFilter.

Definition at line 54 of file ocio_display_filter_vfx2020.cpp.

{
    // processes that data _in_ place
    if (m_processor) {
        OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
        m_processor->apply(img);
    }
}

References m_processor.

◆ filter() [2/2]

void OcioDisplayFilter::filter	(	quint8 *	pixels,
		quint32	numPixels )

overridevirtual

Implements KisDisplayFilter.

◆ lockCurrentColorVisualRepresentation() [1/2]

bool OcioDisplayFilter::lockCurrentColorVisualRepresentation ( ) const

overridevirtual

Implements KisDisplayFilter.

Definition at line 86 of file ocio_display_filter_vfx2020.cpp.

{
    return m_lockCurrentColorVisualRepresentation;
}

References m_lockCurrentColorVisualRepresentation.

◆ lockCurrentColorVisualRepresentation() [2/2]

bool OcioDisplayFilter::lockCurrentColorVisualRepresentation ( ) const

overridevirtual

Implements KisDisplayFilter.

◆ program() [1/2]

QString OcioDisplayFilter::program ( ) const

overridevirtual

Implements KisDisplayFilter.

Definition at line 96 of file ocio_display_filter_vfx2020.cpp.

{
    return m_program;
}

References m_program.

◆ program() [2/2]

QString OcioDisplayFilter::program ( ) const

overridevirtual

Implements KisDisplayFilter.

◆ setLockCurrentColorVisualRepresentation() [1/2]

void OcioDisplayFilter::setLockCurrentColorVisualRepresentation ( bool value )

Definition at line 91 of file ocio_display_filter_vfx2020.cpp.

{
    m_lockCurrentColorVisualRepresentation = value;
}

References m_lockCurrentColorVisualRepresentation, and value().

◆ setLockCurrentColorVisualRepresentation() [2/2]

void OcioDisplayFilter::setLockCurrentColorVisualRepresentation ( bool value )

◆ setupTextures() [1/2]

void OcioDisplayFilter::setupTextures	(	GLFunctions *	f,
		QOpenGLShaderProgram *	program ) const

overridevirtual

Implements KisDisplayFilter.

Definition at line 408 of file ocio_display_filter_vfx2020.cpp.

{
    f->glActiveTexture(GL_TEXTURE0 + 1);
    f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);
    program->setUniformValue(program->uniformLocation("texture1"), 1);
}

References m_lut3dTexID, and program().

◆ setupTextures() [2/2]

void OcioDisplayFilter::setupTextures	(	GLFunctions *	f,
		QOpenGLShaderProgram *	program ) const

overridevirtual

Implements KisDisplayFilter.

◆ updateProcessor() [1/2]

void OcioDisplayFilter::updateProcessor ( )

Look support: As the OCIO docs will tell you, looks are a aesthetic transform that is added onto the mix. A view+display can have it's own assigned Look, or list of looks, and these can be overridden optionally. What the OCIO docs won't tell you is that a display transform won't use the looks attached to it unless "skipColorSpaceConversions" is false... I have no idea what "skipColorSpaceConversions" is beyond what it says on the tin. It is not mentioned in the documentation anywhere. Or on the website. Or how to set it. Or unset it. Why it is apparently set true to begin with. Only that, apparently, this was done with non-color data in mind...

Until there's clear documentation on how to use this feature, I am afraid the override is all we can offer.

Definition at line 101 of file ocio_display_filter_vfx2020.cpp.

{
    if (!config) {
        return;
    }
 
    if (!displayDevice) {
        displayDevice = config->getDefaultDisplay();
    }
 
    if (!view) {
        view = config->getDefaultView(displayDevice);
    }
 
    if (!inputColorSpaceName) {
        inputColorSpaceName = config->getColorSpaceNameByIndex(0);
    }
    if (!look) {
    look = config->getLookNameByIndex(0);
    }
 
    if (!displayDevice || !view || !inputColorSpaceName) {
        return;
    }
 
    OCIO::DisplayTransformRcPtr transform = OCIO::DisplayTransform::Create();
    transform->setInputColorSpaceName(inputColorSpaceName);
    transform->setDisplay(displayDevice);
    transform->setView(view);
 
    if (config->getLook(look)) {
       transform->setLooksOverride(look);
       transform->setLooksOverrideEnabled(true);
    }
 
    OCIO::GroupTransformRcPtr approximateTransform = OCIO::GroupTransform::Create();
 
    // fstop exposure control -- not sure how that translates to our exposure
    {
        float exposureGain = powf(2.0f, exposure);
 
        const qreal minRange = 0.001;
        if (qAbs(blackPoint - whitePoint) < minRange) {
            whitePoint = blackPoint + minRange;
        }
 
        const float oldMin[] = { blackPoint, blackPoint, blackPoint, 0.0f };
        const float oldMax[] = { whitePoint, whitePoint, whitePoint, 1.0f };
 
        const float newMin[] = { 0.0f, 0.0f, 0.0f, 0.0f };
        const float newMax[] = { exposureGain, exposureGain, exposureGain, 1.0f };
 
        float m44[16];
        float offset4[4];
        OCIO::MatrixTransform::Fit(m44, offset4, oldMin, oldMax, newMin, newMax);
        OCIO::MatrixTransformRcPtr mtx =  OCIO::MatrixTransform::Create();
        mtx->setValue(m44, offset4);
        transform->setLinearCC(mtx);
 
        // approximation (no color correction);
        approximateTransform->push_back(mtx);
    }
 
    // channel swizzle
    {
        int channelHot[4];
        switch (swizzle) {
        case LUMINANCE:
            channelHot[0] = 1;
            channelHot[1] = 1;
            channelHot[2] = 1;
            channelHot[3] = 0;
            break;
        case RGBA:
            channelHot[0] = 1;
            channelHot[1] = 1;
            channelHot[2] = 1;
            channelHot[3] = 1;
            break;
        case R:
            channelHot[0] = 1;
            channelHot[1] = 0;
            channelHot[2] = 0;
            channelHot[3] = 0;
            break;
        case G:
            channelHot[0] = 0;
            channelHot[1] = 1;
            channelHot[2] = 0;
            channelHot[3] = 0;
            break;
        case B:
            channelHot[0] = 0;
            channelHot[1] = 0;
            channelHot[2] = 1;
            channelHot[3] = 0;
            break;
        case A:
            channelHot[0] = 0;
            channelHot[1] = 0;
            channelHot[2] = 0;
            channelHot[3] = 1;
        default:
            ;
        }
        float lumacoef[3];
        config->getDefaultLumaCoefs(lumacoef);
        float m44[16];
        float offset[4];
        OCIO::MatrixTransform::View(m44, offset, channelHot, lumacoef);
        OCIO::MatrixTransformRcPtr swizzleTransform = OCIO::MatrixTransform::Create();
        swizzleTransform->setValue(m44, offset);
        transform->setChannelView(swizzleTransform);
    }
 
    // Post-display transform gamma
    {
        float exponent = 1.0f/std::max(1e-6f, static_cast<float>(gamma));
        const float exponent4f[] = { exponent, exponent, exponent, exponent };
        OCIO::ExponentTransformRcPtr expTransform =  OCIO::ExponentTransform::Create();
        expTransform->setValue(exponent4f);
        transform->setDisplayCC(expTransform);
 
        // approximation (no color correction);
        approximateTransform->push_back(expTransform);
    }
 
    try {
        AutoSetAndRestoreThreadLocale l;
        m_processor = config->getProcessor(transform);
    } catch (OCIO::Exception &e) {
        // XXX: How to not break the OCIO shader now?
        errKrita << "OCIO exception while parsing the current context:" << e.what();
        m_shaderDirty = false;
        return;
    }
 
    m_forwardApproximationProcessor = config->getProcessor(approximateTransform, OCIO::TRANSFORM_DIR_FORWARD);
 
    try {
        m_reverseApproximationProcessor = config->getProcessor(approximateTransform, OCIO::TRANSFORM_DIR_INVERSE);
    } catch (...) {
        warnKrita << "OCIO inverted matrix does not exist!";
        //m_reverseApproximationProcessor;
    }
 
    m_shaderDirty = true;
}

References A, B, blackPoint, config, displayDevice, errKrita, exposure, G, gamma, inputColorSpaceName, look, LUMINANCE, m_forwardApproximationProcessor, m_processor, m_reverseApproximationProcessor, m_shaderDirty, R, RGBA, swizzle, view, warnKrita, and whitePoint.

◆ updateProcessor() [2/2]

void OcioDisplayFilter::updateProcessor ( )

◆ updateShader() [1/2]

bool OcioDisplayFilter::updateShader ( )

overridevirtual

Returns: true if the shader should be recompiled

Implements KisDisplayFilter.

Definition at line 266 of file ocio_display_filter_vfx2020.cpp.

{
    if (KisOpenGL::hasOpenGLES()) {
        QOpenGLContext *ctx = QOpenGLContext::currentContext();
 
        KIS_ASSERT_RECOVER_RETURN_VALUE(ctx, false);
        if (ctx->format().majorVersion() >= 3) {
            QOpenGLExtraFunctions *f = ctx->extraFunctions();
            if (f) {
                return updateShaderImpl(f);
            }
        } else if (ctx->hasExtension("GL_OES_texture_half_float") && ctx->hasExtension("GL_EXT_color_buffer_half_float")
                && ctx->hasExtension("GL_OES_texture_half_float_linear")) {
                QOpenGLExtraFunctions *f = ctx->extraFunctions();
                if (f) {
                    return updateShaderImpl(f);
                }
        } else {
            dbgKrita << "OcioDisplayFilter::updateShader (2020)"
                     << "OpenGL ES v2+ support detected but no OES_texture_half_float,"
                        "GL_EXT_color_buffer_half_float or GL_OES_texture_half_float_linear were found";
            return false;
        }
#if defined(QT_OPENGL_3)
    } else if (KisOpenGL::hasOpenGL3()) {
        QOpenGLFunctions_3_2_Core *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_2_Core>();
        if (f) {
            return updateShaderImpl(f);
        }
#endif
    }
 
    // XXX This option can be removed once we move to Qt 5.7+
    if (KisOpenGL::supportsLoD()) {
#if defined(QT_OPENGL_3)
#if defined(Q_OS_MAC) && defined(QT_OPENGL_3_2)
        QOpenGLFunctions_3_2_Core *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_2_Core>();
#else
        QOpenGLFunctions_3_0 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_0>();
#endif
        if (f) {
            return updateShaderImpl(f);
        }
#endif
    }
#if !defined(QT_OPENGL_ES_2)
    QOpenGLFunctions_2_0 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_2_0>();
    if (f) {
        return updateShaderImpl(f);
    }
#endif
 
    return false;
}

References dbgKrita, KisOpenGL::hasOpenGL3(), KisOpenGL::hasOpenGLES(), KIS_ASSERT_RECOVER_RETURN_VALUE, KisOpenGL::supportsLoD(), and updateShaderImpl().

◆ updateShader() [2/2]

bool OcioDisplayFilter::updateShader ( )

overridevirtual

Returns: true if the shader should be recompiled

Implements KisDisplayFilter.

◆ updateShaderImpl() [1/2]

template<class F >

bool OcioDisplayFilter::updateShaderImpl ( F * f )

Definition at line 322 of file ocio_display_filter_vfx2020.cpp.

                                             {
    // check whether we are allowed to use shaders -- though that should
    // work for everyone these days
    KisConfig cfg(true);
    if (!cfg.useOpenGL()) return false;
 
    if (!m_shaderDirty) return false;
 
    if (!f) {
        qWarning() << "Failed to get valid OpenGL functions for OcioDisplayFilter!";
        return false;
    }
 
    f->initializeOpenGLFunctions();
 
    bool shouldRecompileShader = false;
 
    const int lut3DEdgeSize = cfg.ocioLutEdgeSize();
 
    if (m_lut3d.size() == 0) {
        //dbgKrita << "generating lut";
        f->glGenTextures(1, &m_lut3dTexID);
 
        int num3Dentries = 3 * lut3DEdgeSize * lut3DEdgeSize * lut3DEdgeSize;
        m_lut3d.fill(0.0, num3Dentries);
 
        f->glActiveTexture(GL_TEXTURE1);
        f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);
 
        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
        f->glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB16F_ARB,
                        lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,
                        0, GL_RGB, GL_FLOAT, &m_lut3d.constData()[0]);
    }
 
    // Step 1: Create a GPU Shader Description
    OCIO::GpuShaderDesc shaderDesc;
 
    if (KisOpenGL::supportsLoD()) {
        shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_3);
    }
    else {
        shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_0);
    }
 
 
    shaderDesc.setFunctionName("OCIODisplay");
    shaderDesc.setLut3DEdgeLen(lut3DEdgeSize);
 
 
    // Step 2: Compute the 3D LUT
    QString lut3dCacheID = QString::fromLatin1(m_processor->getGpuLut3DCacheID(shaderDesc));
    if (lut3dCacheID != m_lut3dcacheid) {
        //dbgKrita << "Computing 3DLut " << m_lut3dcacheid;
        m_lut3dcacheid = lut3dCacheID;
        m_processor->getGpuLut3D(&m_lut3d[0], shaderDesc);
 
        f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);
        f->glTexSubImage3D(GL_TEXTURE_3D, 0,
                                  0, 0, 0,
                                  lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,
                                  GL_RGB, GL_FLOAT, &m_lut3d[0]);
    }
 
    // Step 3: Generate the shader text
    QString shaderCacheID = QString::fromLatin1(m_processor->getGpuShaderTextCacheID(shaderDesc));
    if (m_program.isEmpty() || shaderCacheID != m_shadercacheid) {
        //dbgKrita << "Computing Shader " << m_shadercacheid;
 
        m_shadercacheid = shaderCacheID;
 
        std::ostringstream os;
        os << m_processor->getGpuShaderText(shaderDesc) << "\n";
 
        m_program = QString::fromLatin1(os.str().c_str());
        shouldRecompileShader = true;
    }
 
    m_shaderDirty = false;
    return shouldRecompileShader;
}

References GL_CLAMP_TO_EDGE, m_lut3d, m_lut3dcacheid, m_lut3dTexID, m_processor, m_program, m_shadercacheid, m_shaderDirty, KisConfig::ocioLutEdgeSize(), KisOpenGL::supportsLoD(), and KisConfig::useOpenGL().

◆ updateShaderImpl() [2/2]

template<class F >

bool OcioDisplayFilter::updateShaderImpl ( F * f )

◆ useInternalColorManagement() [1/2]

bool OcioDisplayFilter::useInternalColorManagement ( ) const

overridevirtual

Implements KisDisplayFilter.

Definition at line 81 of file ocio_display_filter_vfx2020.cpp.

{
    return forceInternalColorManagement;
}

References forceInternalColorManagement.

◆ useInternalColorManagement() [2/2]

bool OcioDisplayFilter::useInternalColorManagement ( ) const

overridevirtual

Implements KisDisplayFilter.

Member Data Documentation

◆ blackPoint [1/2]

float OcioDisplayFilter::blackPoint {0.0}

Definition at line 65 of file ocio_display_filter_vfx2020.h.

65{0.0};

◆ blackPoint [2/2]

double OcioDisplayFilter::blackPoint

Definition at line 92 of file ocio_display_filter_vfx2021.h.

◆ config

OCIO::ConstConfigRcPtr OcioDisplayFilter::config

Definition at line 56 of file ocio_display_filter_vfx2020.h.

◆ displayDevice

const char * OcioDisplayFilter::displayDevice {nullptr}

Definition at line 59 of file ocio_display_filter_vfx2020.h.

59{nullptr};

◆ exposure [1/2]

float OcioDisplayFilter::exposure {0.0}

Definition at line 63 of file ocio_display_filter_vfx2020.h.

63{0.0};

◆ exposure [2/2]

double OcioDisplayFilter::exposure

Definition at line 90 of file ocio_display_filter_vfx2021.h.

◆ forceInternalColorManagement

bool OcioDisplayFilter::forceInternalColorManagement {false}

Definition at line 67 of file ocio_display_filter_vfx2020.h.

67{false};

◆ gamma [1/2]

float OcioDisplayFilter::gamma {0.0}

Definition at line 64 of file ocio_display_filter_vfx2020.h.

64{0.0};

◆ gamma [2/2]

double OcioDisplayFilter::gamma

Definition at line 91 of file ocio_display_filter_vfx2021.h.

◆ inputColorSpaceName

const char * OcioDisplayFilter::inputColorSpaceName {nullptr}

Definition at line 58 of file ocio_display_filter_vfx2020.h.

58{nullptr};

◆ look

const char * OcioDisplayFilter::look {nullptr}

Definition at line 61 of file ocio_display_filter_vfx2020.h.

61{nullptr};

◆ m_forwardApproximationProcessor

OCIO::ConstProcessorRcPtr OcioDisplayFilter::m_forwardApproximationProcessor

private

Definition at line 73 of file ocio_display_filter_vfx2020.h.

◆ m_forwardApproximationProcessorCPU

OCIO::ConstCPUProcessorRcPtr OcioDisplayFilter::m_forwardApproximationProcessorCPU

private

Definition at line 103 of file ocio_display_filter_vfx2021.h.

◆ m_interface

KisExposureGammaCorrectionInterface * OcioDisplayFilter::m_interface {nullptr}

private

Definition at line 75 of file ocio_display_filter_vfx2020.h.

75{nullptr};

◆ m_lockCurrentColorVisualRepresentation

bool OcioDisplayFilter::m_lockCurrentColorVisualRepresentation {false}

private

Definition at line 77 of file ocio_display_filter_vfx2020.h.

77{false};

◆ m_lut3d

QVector<float> OcioDisplayFilter::m_lut3d

private

Definition at line 81 of file ocio_display_filter_vfx2020.h.

◆ m_lut3dcacheid

QString OcioDisplayFilter::m_lut3dcacheid

private

Definition at line 82 of file ocio_display_filter_vfx2020.h.

◆ m_lut3dTexID

GLuint OcioDisplayFilter::m_lut3dTexID {0}

private

Definition at line 80 of file ocio_display_filter_vfx2020.h.

80{0};

◆ m_lut3dTexIDs

std::vector<KisTextureEntry> OcioDisplayFilter::m_lut3dTexIDs

private

Definition at line 110 of file ocio_display_filter_vfx2021.h.

◆ m_lut3dUniforms

std::vector<KisTextureUniform> OcioDisplayFilter::m_lut3dUniforms

private

Definition at line 113 of file ocio_display_filter_vfx2021.h.

◆ m_processor

OCIO::ConstProcessorRcPtr OcioDisplayFilter::m_processor

private

Definition at line 71 of file ocio_display_filter_vfx2020.h.

◆ m_processorCPU

OCIO::ConstCPUProcessorRcPtr OcioDisplayFilter::m_processorCPU

private

Definition at line 101 of file ocio_display_filter_vfx2021.h.

◆ m_program

QString OcioDisplayFilter::m_program

private

Definition at line 79 of file ocio_display_filter_vfx2020.h.

◆ m_reverseApproximationProcessor

OCIO::ConstProcessorRcPtr OcioDisplayFilter::m_reverseApproximationProcessor

private

Definition at line 72 of file ocio_display_filter_vfx2020.h.

◆ m_reverseApproximationProcessorCPU

OCIO::ConstCPUProcessorRcPtr OcioDisplayFilter::m_reverseApproximationProcessorCPU

private

Definition at line 102 of file ocio_display_filter_vfx2021.h.

◆ m_shadercacheid

QString OcioDisplayFilter::m_shadercacheid

private

Definition at line 83 of file ocio_display_filter_vfx2020.h.

◆ m_shaderDirty

bool OcioDisplayFilter::m_shaderDirty {true}

private

Definition at line 85 of file ocio_display_filter_vfx2020.h.

85{true};

◆ swizzle

OCIO_CHANNEL_SWIZZLE OcioDisplayFilter::swizzle {RGBA}

Definition at line 62 of file ocio_display_filter_vfx2020.h.

62{RGBA};

◆ view

const char * OcioDisplayFilter::view {nullptr}

Definition at line 60 of file ocio_display_filter_vfx2020.h.

60{nullptr};

◆ whitePoint [1/2]

float OcioDisplayFilter::whitePoint {0.0}

Definition at line 66 of file ocio_display_filter_vfx2020.h.

66{0.0};

◆ whitePoint [2/2]

double OcioDisplayFilter::whitePoint

Definition at line 93 of file ocio_display_filter_vfx2021.h.

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

plugins/dockers/lut/ocio_display_filter_vfx2020.h
plugins/dockers/lut/ocio_display_filter_vfx2021.h
plugins/dockers/lut/ocio_display_filter_vfx2020.cpp
plugins/dockers/lut/ocio_display_filter_vfx2021.cpp

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ OcioDisplayFilter() [1/2]

◆ ~OcioDisplayFilter() [1/2]

◆ OcioDisplayFilter() [2/2]

◆ ~OcioDisplayFilter() [2/2]

Member Function Documentation

◆ approximateForwardTransformation() [1/2]

◆ approximateForwardTransformation() [2/2]

◆ approximateInverseTransformation() [1/2]

◆ approximateInverseTransformation() [2/2]

◆ correctionInterface() [1/2]

◆ correctionInterface() [2/2]

◆ filter() [1/2]

◆ filter() [2/2]

◆ lockCurrentColorVisualRepresentation() [1/2]

◆ lockCurrentColorVisualRepresentation() [2/2]

◆ program() [1/2]

◆ program() [2/2]

◆ setLockCurrentColorVisualRepresentation() [1/2]

◆ setLockCurrentColorVisualRepresentation() [2/2]

◆ setupTextures() [1/2]

◆ setupTextures() [2/2]

◆ updateProcessor() [1/2]

◆ updateProcessor() [2/2]

◆ updateShader() [1/2]

◆ updateShader() [2/2]

◆ updateShaderImpl() [1/2]

◆ updateShaderImpl() [2/2]

◆ useInternalColorManagement() [1/2]

◆ useInternalColorManagement() [2/2]

Member Data Documentation

◆ blackPoint [1/2]

◆ blackPoint [2/2]

◆ config

◆ displayDevice

◆ exposure [1/2]

◆ exposure [2/2]

◆ forceInternalColorManagement

◆ gamma [1/2]

◆ gamma [2/2]

◆ inputColorSpaceName

◆ look

◆ m_forwardApproximationProcessor

◆ m_forwardApproximationProcessorCPU

◆ m_interface

◆ m_lockCurrentColorVisualRepresentation

◆ m_lut3d

◆ m_lut3dcacheid

◆ m_lut3dTexID

◆ m_lut3dTexIDs

◆ m_lut3dUniforms

◆ m_processor

◆ m_processorCPU

◆ m_program

◆ m_reverseApproximationProcessor

◆ m_reverseApproximationProcessorCPU

◆ m_shadercacheid

◆ m_shaderDirty

◆ swizzle

◆ view

◆ whitePoint [1/2]

◆ whitePoint [2/2]