find_package(OCIO)

find_package(OpenColorIO)

set_package_properties(OCIO PROPERTIES

set_package_properties(OpenColorIO PROPERTIES

macro_bool_to_01(OCIO_FOUND HAVE_OCIO)

macro_bool_to_01(OpenColorIO_FOUND HAVE_OCIO)

    fragColor = OCIODisplay(col, texture1);

    fragColor = OCIODisplay(col);

    virtual GLuint lutTexture() const = 0;

    virtual void setupTextures(QOpenGLFunctions *f, QOpenGLShaderProgram *program) const = 0;

                glActiveTexture(GL_TEXTURE0 + 1);

                d->displayFilter->setupTextures(this, d->displayShader);

                glBindTexture(GL_TEXTURE_3D, d->displayFilter->lutTexture());

                d->displayShader->setUniformValue(d->displayShader->location(Uniform::Texture1), 1);

target_link_libraries(kritalutdocker kritaui ${Boost_SYSTEM_LIBRARY} ${OCIO_LIBRARIES})

target_link_libraries(kritalutdocker kritaui ${Boost_SYSTEM_LIBRARY} OpenColorIO::OpenColorIO)

 *  Copyright (c) 2012 Boudewijn Rempt <boud@valdyas.org>

 *  SPDX-FileCopyrightText: 2012 Boudewijn Rempt <boud@valdyas.org>

 *  SPDX-FileCopyrightText: 2021 L. E. Segovia <amy@amyspark.me>

 *  This program is free software; you can redistribute it and/or modify

 *  SPDX-License-Identifier: GPL-2.0-or-later

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

#include <math.h>

#include <cstdlib>

#include <QOpenGLContext>

#include <QOpenGLExtraFunctions>

#include <QOpenGLFunctions_2_0>

#include <QOpenGLFunctions_3_0>

#include <QOpenGLFunctions_3_2_Core>

#include <kis_debug.h>

#include <QOpenGLContext>

#include <QOpenGLFunctions_3_2_Core>

#if defined(QT_OPENGL_ES_2)

#include <QOpenGLFunctions_3_0>

#define GL_RGBA32F_ARB GL_RGBA32F_EXT

#include <QOpenGLFunctions_2_0>

#define GL_RGB32F_ARB GL_RGB32F_EXT

#include <QOpenGLExtraFunctions>

#endif

    , m_lut3dTexID(0)

    , m_lut3dTexIDs()

    , m_lut3dUniforms()

KisExposureGammaCorrectionInterface* OcioDisplayFilter::correctionInterface() const

KisExposureGammaCorrectionInterface *OcioDisplayFilter::correctionInterface() const

        OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);

        OCIO::PackedImageDesc img(reinterpret_cast<float *>(pixels), numPixels, 1, 4);

        m_processor->apply(img);

        m_processor->getDefaultCPUProcessor()->apply(img);

        OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);

        OCIO::PackedImageDesc img(reinterpret_cast<float *>(pixels), numPixels, 1, 4);

        m_revereseApproximationProcessor->apply(img);

        m_revereseApproximationProcessor->getDefaultCPUProcessor()->apply(img);

        OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);

        OCIO::PackedImageDesc img(reinterpret_cast<float *>(pixels), numPixels, 1, 4);

        m_forwardApproximationProcessor->apply(img);

        m_forwardApproximationProcessor->getDefaultCPUProcessor()->apply(img);

    look = config->getLookNameByIndex(0);

        look = config->getLookNameByIndex(0);

    OCIO::DisplayTransformRcPtr transform = OCIO::DisplayTransform::Create();

    OCIO::DisplayViewTransformRcPtr transform = OCIO::DisplayViewTransform::Create();

    transform->setInputColorSpaceName(inputColorSpaceName);

    transform->setSrc(inputColorSpaceName);

       transform->setLooksOverride(look);

        vpt->setLooksOverride(look);

       transform->setLooksOverrideEnabled(true);

        vpt->setLooksOverrideEnabled(true);

        float exposureGain = powf(2.0f, exposure);

        const double exposureGain = pow(2.0, exposure);

        const qreal minRange = 0.001;

        const double minRange = 0.001;

        const float oldMin[] = { blackPoint, blackPoint, blackPoint, 0.0f };

        const double oldMin[] = {blackPoint, blackPoint, blackPoint, 0.0};

        const float oldMax[] = { whitePoint, whitePoint, whitePoint, 1.0f };

        const double oldMax[] = {whitePoint, whitePoint, whitePoint, 1.0};

        const float newMin[] = { 0.0f, 0.0f, 0.0f, 0.0f };

        const double newMin[] = {0.0, 0.0, 0.0, 0.0};

        const float newMax[] = { exposureGain, exposureGain, exposureGain, 1.0f };

        const double newMax[] = {exposureGain, exposureGain, exposureGain, 1.0};

        float m44[16];

        double m44[16];

        float offset4[4];

        double offset4[4];

        OCIO::MatrixTransformRcPtr mtx =  OCIO::MatrixTransform::Create();

        OCIO::MatrixTransformRcPtr mtx = OCIO::MatrixTransform::Create();

        mtx->setValue(m44, offset4);

        mtx->setMatrix(m44);

        transform->setLinearCC(mtx);

        mtx->setOffset(offset4);

        vpt->setLinearCC(mtx);

        approximateTransform->push_back(mtx);

        approximateTransform->appendTransform(mtx);

        default:

        default:;

            ;

        float lumacoef[3];

        double lumacoef[3];

        float m44[16];

        double m44[16];

        float offset[4];

        double offset[4];

        swizzleTransform->setValue(m44, offset);

        swizzleTransform->setMatrix(m44);

        transform->setChannelView(swizzleTransform);

        swizzleTransform->setOffset(offset);

        vpt->setChannelView(swizzleTransform);

        float exponent = 1.0f/std::max(1e-6f, static_cast<float>(gamma));

        double exponent = 1.0 / std::max(1e-6, gamma);

        const float exponent4f[] = { exponent, exponent, exponent, exponent };

        const double exponent4f[] = {exponent, exponent, exponent, exponent};

        OCIO::ExponentTransformRcPtr expTransform =  OCIO::ExponentTransform::Create();

        OCIO::ExponentTransformRcPtr expTransform = OCIO::ExponentTransform::Create();

        transform->setDisplayCC(expTransform);

        vpt->setDisplayCC(expTransform);

        approximateTransform->push_back(expTransform);

        approximateTransform->appendTransform(expTransform);

    m_processor = config->getProcessor(transform);

    try {

        m_processor = vpt->getProcessor(config, config->getCurrentContext());

    } 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_revereseApproximationProcessor;

        // m_revereseApproximationProcessor;

#ifdef Q_OS_MAC

#if defined(QT_OPENGL_3)

#if defined(Q_OS_MAC) && defined(QT_OPENGL_3_2)

    QOpenGLExtraFunctions *f = QOpenGLContext::currentContext()->extraFunctions();

#if !defined(QT_OPENGL_ES_2)

    QOpenGLFunctions_2_0 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_2_0>();

template <class F>

template<class F>

bool OcioDisplayFilter::updateShaderImpl(F *f) {

bool OcioDisplayFilter::updateShaderImpl(F *f)

{

    if (!cfg.useOpenGL()) return false;

    if (!cfg.useOpenGL())

        return false;

    if (!m_shaderDirty) return false;

    if (!m_shaderDirty)

        return false;

    const int lut3DEdgeSize = cfg.ocioLutEdgeSize();

    // Step 1: Create a GPU Shader Description

    OCIO::GpuShaderDescRcPtr shaderDesc = OCIO::GpuShaderDesc::CreateShaderDesc();

    if (m_lut3d.size() == 0) {

#if OCIO_VERSION_HEX >= 0x2010100 || OCIO_VERSION_HEX >= 0x2020000

        //dbgKrita << "generating lut";

    if (KisOpenGL::supportsLoD()) {

        f->glGenTextures(1, &m_lut3dTexID);

        shaderDesc->setLanguage(OCIO::GPU_LANGUAGE_GLSL_ES_3_0);

    } else {

        shaderDesc->setLanguage(OCIO::GPU_LANGUAGE_GLSL_ES_1_0);

    }

#else

    if (KisOpenGL::supportsLoD()) {

        shaderDesc->setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_3);

    } else {

        shaderDesc->setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_2);

    }

#endif

        int num3Dentries = 3 * lut3DEdgeSize * lut3DEdgeSize * lut3DEdgeSize;

    shaderDesc->setFunctionName("OCIODisplay");

        m_lut3d.fill(0.0, num3Dentries);

    shaderDesc->setResourcePrefix("ocio_");

        f->glActiveTexture(GL_TEXTURE1);

    // Step 2: Compute the 3D LUT

        f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);

#if OCIO_VERSION_HEX >= 0x2010100 || OCIO_VERSION_HEX >= 0x2020000

    // ensure the new GPU pipeline is used with our GLES3 patch

    // this way users won't run into errors when using Angle along with OCIO

    const auto gpu = m_processor->getOptimizedGPUProcessor(OCIO::OptimizationFlags::OPTIMIZATION_DEFAULT);

#else

    const int lut3DEdgeSize = cfg.ocioLutEdgeSize();

    const auto gpu =

        m_processor->getOptimizedLegacyGPUProcessor(OCIO::OptimizationFlags::OPTIMIZATION_DEFAULT, lut3DEdgeSize);

#endif

        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    gpu->extractGpuShaderInfo(shaderDesc);

        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    // OCIO v2 assumes you'll use the OglApp helpers

        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    // these are unusable from a Qt backend, because they rely on GLUT/GLFW

        f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

    // ociodisplay original pipeline:

        f->glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB16F_ARB,

    // https://github.com/AcademySoftwareFoundation/OpenColorIO/blob/508b3f4a0618435aeed2f45058208bdfa99e0887/src/apps/ociodisplay/main.cpp

                        lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,

    // ociodisplay new pipeline is a single call:

                        0, GL_RGB, GL_FLOAT, &m_lut3d.constData()[0]);

    // https://github.com/AcademySoftwareFoundation/OpenColorIO/blob/ffddc3341f5775c7866fe2c93275e1d5e0b0540f/src/apps/ociodisplay/main.cpp#L427

    // we need to replicate this loop:

    // https://github.com/AcademySoftwareFoundation/OpenColorIO/blob/dd59baf555656e09f52c3838e85ccf154497ec1d/src/libutils/oglapphelpers/oglapp.cpp#L191-L223

    // calls functions from here:

    // https://github.com/AcademySoftwareFoundation/OpenColorIO/blob/dd59baf555656e09f52c3838e85ccf154497ec1d/src/libutils/oglapphelpers/glsl.cpp

    for (const auto &tex : m_lut3dTexIDs) {

        f->glDeleteTextures(1, &tex.m_uid);

    // Step 1: Create a GPU Shader Description

    m_lut3dTexIDs.clear();

    OCIO::GpuShaderDesc shaderDesc;

    if (KisOpenGL::supportsLoD()) {

    // This is the first available index for the textures.

        shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_3);

    unsigned currIndex = 1;

    }

    else {

    // Process the 3D LUT first.

        shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_0);

    const unsigned maxTexture3D = shaderDesc->getNum3DTextures();

    for (unsigned idx = 0; idx < maxTexture3D; ++idx) {

        // 1. Get the information of the 3D LUT.

        const char *textureName = nullptr;

        const char *samplerName = nullptr;

        unsigned edgelen = 0;

        OCIO::Interpolation interpolation = OCIO::INTERP_LINEAR;

        shaderDesc->get3DTexture(idx, textureName, samplerName, edgelen, interpolation);

        if (!textureName || !*textureName || !samplerName || !*samplerName || edgelen == 0) {

            errOpenGL << "The texture data is corrupted";

            return false;

        }

        const float *values = nullptr;

        shaderDesc->get3DTextureValues(idx, values);

        if (!values) {

            errOpenGL << "The texture values are missing";

            return false;

        }

        // 2. Allocate the 3D LUT.

        unsigned texId = 0;

        {

            if (values == nullptr) {

                errOpenGL << "3D LUT" << idx << "Missing texture data";

                return false;

            }

            f->glGenTextures(1, &texId);

            f->glActiveTexture(GL_TEXTURE0 + currIndex);

            f->glBindTexture(GL_TEXTURE_3D, texId);

            {

                if (interpolation == OCIO::INTERP_NEAREST) {

                    f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

                    f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

                } else {

                    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_RGB32F_ARB, edgelen, edgelen, edgelen, 0, GL_RGB, GL_FLOAT, values);

        }

        // 3. Keep the texture id & name for the later enabling.

        m_lut3dTexIDs.push_back({texId, textureName, samplerName, GL_TEXTURE_3D});

        currIndex++;

    shaderDesc.setFunctionName("OCIODisplay");

    const unsigned maxTexture2D = shaderDesc->getNumTextures();

    shaderDesc.setLut3DEdgeLen(lut3DEdgeSize);

    for (unsigned idx = 0; idx < maxTexture2D; ++idx) {

        // 1. Get the information of the 1D LUT.

    // Step 2: Compute the 3D LUT

        if (!textureName || !*textureName || !samplerName || !*samplerName || width == 0) {

    QString lut3dCacheID = QString::fromLatin1(m_processor->getGpuLut3DCacheID(shaderDesc));

            errOpenGL << "The texture data is corrupted";

    if (lut3dCacheID != m_lut3dcacheid) {

            return false;

        //dbgKrita << "Computing 3DLut " << m_lut3dcacheid;

        }

        m_lut3dcacheid = lut3dCacheID;

        m_processor->getGpuLut3D(&m_lut3d[0], shaderDesc);

        const float *values = nullptr;

        shaderDesc->getTextureValues(idx, values);

        f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);

        if (!values) {

        f->glTexSubImage3D(GL_TEXTURE_3D, 0,

            errOpenGL << "The texture values are missing";

                                  0, 0, 0,

            return false;

                                  lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,

        }

                                  GL_RGB, GL_FLOAT, &m_lut3d[0]);

        // 2. Allocate the 1D LUT (a 2D texture is needed to hold large LUTs).

        unsigned texId = 0;

        {

            if (values == nullptr) {

                errOpenGL << "1D LUT" << idx << "Missing texture data.";

                return false;

            }

            unsigned internalformat = GL_RGB32F_ARB;

            unsigned format = GL_RGB;

            if (channel == OCIO::GpuShaderCreator::TEXTURE_RED_CHANNEL) {

                internalformat = GL_R32F;

                format = GL_RED;

            }

            f->glGenTextures(1, &texId);

            f->glActiveTexture(GL_TEXTURE0 + currIndex);

#if OCIO_VERSION_HEX >= 0x2010100 || OCIO_VERSION_HEX >= 0x2020000

#else

            // 1D Textures are unsupported by OpenGL ES.

            // https://github.com/AcademySoftwareFoundation/OpenColorIO/issues/1486

            if (height > 1) {

#endif

                f->glBindTexture(GL_TEXTURE_2D, texId);

                {

                    if (interpolation == OCIO::INTERP_NEAREST) {

                        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

                        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

                    } else {

                        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

                        f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

                    }

                    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

                    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

                    f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

                }

                f->glTexImage2D(GL_TEXTURE_2D, 0, internalformat, width, height, 0, format, GL_FLOAT, values);

#if OCIO_VERSION_HEX >= 0x2010100 || OCIO_VERSION_HEX >= 0x2020000

#else

            } else {

                errOpenGL << "1D texture detected @" << idx << ", not supported by OpenGLES";

                return false;

            }

#endif

        }

        // 3. Keep the texture id & name for the later enabling.

        unsigned type = GL_TEXTURE_2D;

        m_lut3dTexIDs.push_back({texId, textureName, samplerName, type});

        currIndex++;

    QString shaderCacheID = QString::fromLatin1(m_processor->getGpuShaderTextCacheID(shaderDesc));

    QString shaderCacheID = QString::fromLatin1(shaderDesc->getCacheID());

        //dbgKrita << "Computing Shader " << m_shadercacheid;

        // dbgKrita << "Computing Shader " << m_shadercacheid;

        std::ostringstream os;

        m_program = QString::fromLatin1("%1\n").arg(shaderDesc->getShaderText());

        os << m_processor->getGpuShaderText(shaderDesc) << "\n";

        m_program = QString::fromLatin1(os.str().c_str());

 *  Copyright (c) 2012 Boudewijn Rempt <boud@valdyas.org>

 *  SPDX-FileCopyrightText: 2012 Boudewijn Rempt <boud@valdyas.org>

 *  SPDX-FileCopyrightText: 2021 L. E. Segovia <amy@amyspark.me>

 *  This program is free software; you can redistribute it and/or modify

 *  SPDX-License-Identifier: GPL-2.0-or-later

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

#include <OpenColorIO/OpenColorIO.h>

#include <kis_exposure_gamma_correction_interface.h>

#include <OpenColorIO/OpenColorTransforms.h>

#include <QVector>

#include "kis_exposure_gamma_correction_interface.h"

enum OCIO_CHANNEL_SWIZZLE {

enum OCIO_CHANNEL_SWIZZLE { LUMINANCE, RGBA, R, G, B, A };

    LUMINANCE,

    RGBA,

struct KisTextureUniform {

    R,

public:

    G,

    KisTextureUniform(const QString &name, const OCIO::GpuShaderDesc::UniformData &data)

    B,

        : m_name(name)

    A

        , m_data(data)

    {

    }

    QString m_name;

    OCIO::GpuShaderDesc::UniformData m_data;

private:

    KisTextureUniform() = delete;

};

struct KisTextureEntry {

    unsigned m_uid = -1;

    QString m_textureName;

    QString m_samplerName;

    unsigned m_type = -1;

    KisTextureEntry(unsigned uid, const QString &textureName, const QString &samplerName, unsigned type)

        : m_uid(uid)

        , m_textureName(textureName)

        , m_samplerName(samplerName)

        , m_type(type)

    {

    }

    void filter(quint8 *pixels, quint32 numPixels);

    void filter(quint8 *pixels, quint32 numPixels) override;

    void approximateInverseTransformation(quint8 *pixels, quint32 numPixels);

    void approximateInverseTransformation(quint8 *pixels, quint32 numPixels) override;

    void approximateForwardTransformation(quint8 *pixels, quint32 numPixels);

    void approximateForwardTransformation(quint8 *pixels, quint32 numPixels) override;

    bool useInternalColorManagement() const;

    bool useInternalColorManagement() const override;

    bool lockCurrentColorVisualRepresentation() const;

    bool lockCurrentColorVisualRepresentation() const override;

    bool updateShader();

    bool updateShader() override;

    template <class F>

    template<class F>

    KisExposureGammaCorrectionInterface *correctionInterface() const;

    void setupTextures(QOpenGLFunctions *f, QOpenGLShaderProgram *program) const override;

    virtual QString program() const;

    KisExposureGammaCorrectionInterface *correctionInterface() const override;

    GLuint lutTexture() const;

    QString program() const override;

    float exposure;

    double exposure;

    float gamma;

    double gamma;

    float blackPoint;

    double blackPoint;

    float whitePoint;

    double whitePoint;

    GLuint m_lut3dTexID;

    std::vector<KisTextureEntry> m_lut3dTexIDs;

    QVector<float> m_lut3d;

    LINK_LIBRARIES kritaui ${OCIO_LIBRARIES} KF5::I18n Qt5::Test

    LINK_LIBRARIES kritaui OpenColorIO::OpenColorIO KF5::I18n Qt5::Test

    <height>286</height>

    <height>328</height>

       <layout class="QHBoxLayout" name="horizontalLayout" stretch="1,0,0">

       <layout class="QHBoxLayout" name="horizontalLayout" stretch="0,1,0,0">