CST_simple.dctl

/*
Color Space Transform Utility
Created by Greyson Sawyer

This DCTL converts between different color spaces and gamma encodings.

QUESTION: How is this DCTL better than the Color Space Transform plugin?
ANSWER: It's not! This DCTL is designed as a reference to help build custom DCTLs.
I attempted to make this DCTL as readable as possible.

EXAMPLE USAGE: 
You are creating a DCTL that needs to handle multiple color spaces/gammas. 
Instead of building the color space transformation logic from scratch,
you can copy this code and adapt it to your needs 💚


This DCTL is identical to the CST plugin but doesn't have:
-Tone mapping
-Gamut mapping
-White point adaptation toggle

FULL VERSION:
Here's my DCTL that includes those features (less copy-pastable):
https://github.com/Greyson-Sawyer/DCTL/blob/main/CST_full.dctl


PROCESS OVERVIEW:
1. Convert input gamma --> linear.
2. Apply inverse OOTF (if enabled).
3. Transform input color space --> XYZ color space.
4. Transform XYZ color space --> output color space.
5. Apply forward OOTF (if enabled).
6. Convert linear --> output gamma.

*/


// ===============================
// SECTION 1: 🛠️ UI Parameters 
// ===============================

// Input Color Space
DEFINE_UI_PARAMS(input_color_space, Input Color Space, DCTLUI_COMBO_BOX, 3, { ic0, ic1, ic2, ic3, ic4, ic5, ic6, ic7, ic8, ic9, ic10, ic11, ic12, ic13, ic14 }, { ACES (AP0), ACES (AP1), Apple Wide Gamut RGB, ARRI Wide Gamut 3, ARRI Wide Gamut 4, DaVinci Wide Gamut, Fuji F-Gamut, REDWideGamutRGB, Sony S-Gamut3.Cine, P3-DCI, P3-D60, P3-D65, Rec.2020, Rec.709, XYZ (CIE) })

// Input Gamma
DEFINE_UI_PARAMS(input_gamma, Input Gamma, DCTLUI_COMBO_BOX, 3, { ig0, ig1, ig2, ig3, ig4, ig5, ig6, ig7, ig8, ig9, ig10, ig11, ig12, ig13, ig14 }, { ACEScc, ACEScct, Apple Log, ARRI LogC3, ARRI LogC4, DaVinci Intermediate, Fuji F-Log, Fuji F-Log2, Gamma 2.2, Gamma 2.4, Gamma 2.6, Linear, Rec.709, RED Log3G10, Sony S-Log3 })

// Output Color Space
DEFINE_UI_PARAMS(output_color_space, Output Color Space, DCTLUI_COMBO_BOX, 13, { oc0, oc1, oc2, oc3, oc4, oc5, oc6, oc7, oc8, oc9, oc10, oc11, oc12, oc13, oc14 }, { ACES (AP0), ACES (AP1), Apple Wide Gamut RGB, ARRI Wide Gamut 3, ARRI Wide Gamut 4, DaVinci Wide Gamut, Fuji F-Gamut, REDWideGamutRGB, Sony S-Gamut3.Cine, P3-DCI, P3-D60, P3-D65, Rec.2020, Rec.709, XYZ (CIE) })

// Output Gamma
DEFINE_UI_PARAMS(output_gamma, Output Gamma, DCTLUI_COMBO_BOX, 9, { og0, og1, og2, og3, og4, og5, og6, og7, og8, og9, og10, og11, og12, og13, og14 }, { ACEScc, ACEScct, Apple Log, ARRI LogC3, ARRI LogC4, DaVinci Intermediate, Fuji F-Log, Fuji F-Log2, Gamma 2.2, Gamma 2.4, Gamma 2.6, Linear, Rec.709, RED Log3G10, Sony S-Log3 })

// Forward OOTF
DEFINE_UI_PARAMS(forward_ootf, Apply Forward OOTF, DCTLUI_CHECK_BOX, 1)

// Inverse OOTF
DEFINE_UI_PARAMS(inverse_ootf, Apply Inverse OOTF, DCTLUI_CHECK_BOX, 0)


// ===============================
// SECTION 2: 📌 Constants & Utility
// ===============================

// Custom powf function to handle negative base values.
__DEVICE__ float powf(float base, float exp) {
    return _copysignf(_powf(_fabs(base), exp), base);
}

// Enumeration for gamma types
// Necessary for gamma encoding and decoding functions.
typedef enum {
    ACEScc,
    ACEScct,
    Apple_Log,
    ARRI_LogC3,
    ARRI_LogC4,
    DaVinci_Intermediate,
    Fuji_F_Log,
    Fuji_F_Log2,
    Gamma_2_2,
    Gamma_2_4,
    Gamma_2_6,
    Linear,
    Rec709,
    RED_Log3G10,
    Sony_S_Log3
} GammaType;


// ===============================
// SECTION 3: 🌘 Gamma Conversion
// ===============================

__DEVICE__ float gamma_to_linear(float in, GammaType gamma_type) {
    switch (gamma_type) {
        case ACEScc:  
        {
            // ACEScc to Linear
            const float a    = 17.52f;
            const float b    = 9.72f;
            const float cut1 = -b / a;
            const float cut2 = 1.468f;

            if (in <= cut1) {
                return (powf(2.0f, (in * a - b)) - powf(2.0f, -16.0f)) * 0.5f;
            } else if (in < cut2) {
                return powf(2.0f, in * a - b);
            } else {
                return 65504.0f;
            }
        }
        case ACEScct:
        {
            // ACEScct to Linear
            const float a   = 17.52f;
            const float b   = 9.72f;
            const float m   = 10.5402377416545f;
            const float k0  = 0.0729055341958355f;
            const float k1  = 0.155251141552511f;
            const float cut = 1.468f;

            if (in <= k1) {
                return (in - k0) / m;
            } else if (in < cut) {
                return powf(2.0f, in * a - b);
            } else {
                return 65504.0f;
            }
        }
        case ARRI_LogC3:
        {
            // ARRI LogC3 to Linear
            const float a   = 5.555556f;
            const float b   = 0.052272f;
            const float c   = 0.247190f;
            const float d   = 0.385537f;
            const float e   = 5.367655f;
            const float f   = 0.092809f;
            const float cut = (e * 0.010591f) + f;

            if (in > cut) {
                return (powf(10.0f, (in - d) / c) - b) / a;
            } else {
                return (in - f) / e;
            }
        }
        case ARRI_LogC4:
        {
            // ARRI LogC4 to Linear
            const float a   = 2231.91177f;
            const float b   = 0.9070295f;
            const float c   = 0.0929705f;
            const float s   = 0.11343535f;
            const float t   = -0.01807264f;

            if (in < 0.0f) {
                return in * s + t;
            } else {
                float p = 14.0f * (in - c) / b + 6.0f;
                return (powf(2.0f, p) - 64.0f) / a;
            }
        }
        case Apple_Log:
        {
            // Apple Log to Linear
            const float R0 = -0.05641088f;
            const float Rt = 0.01f;
            const float c  = 47.28711236f;
            const float b  = 0.00964052f;
            const float y  = 0.08550479f;
            const float d  = 0.69336945f;
            const float Pt = c * powf(Rt - R0, 2.0f);

            if (in >= Pt) {
                return _exp2f((in - d) / y) - b;
            } else if (in > 0.0f) {
                return _sqrtf(in / c) + R0;
            } else {
                return R0;
            }
        }
        case DaVinci_Intermediate:
        {
            // DaVinci Intermediate to Linear
            const float A       = 0.0075f;
            const float B       = 7.0f;
            const float C       = 0.07329248f;
            const float M       = 10.44426855f;
            const float log_cut = 0.02740668f;

            if (in > log_cut) {
                return powf(2.0f, (in / C) - B) - A;
            } else {
                return in / M;
            }
        }
        case Fuji_F_Log:
        {
            // Fuji F-Log to Linear
            const float a   = 0.555556f;
            const float b   = 0.009468f;
            const float c   = 0.344676f;
            const float d   = 0.790453f;
            const float e   = 8.735631f;
            const float f   = 0.092864f;
            const float cut = 0.100537775223865f;

            if (in >= cut) {
                return (powf(10.0f, (in - d) / c) - b) / a;
            } else {
                return (in - f) / e;
            }
        }
        case Fuji_F_Log2:
        {
            // Fuji F-Log2 to Linear
            const float a   = 5.555556f;
            const float b   = 0.064829f;
            const float c   = 0.245281f;
            const float d   = 0.384316f;
            const float e   = 8.799461f;
            const float f   = 0.092864f;
            const float cut = 0.100686685370811f;

            if (in >= cut) {
                return (powf(10.0f, (in - d) / c) - b) / a;
            } else {
                return (in - f) / e;
            }
        }
        case RED_Log3G10:
        {
            // RED Log3G10 to Linear
            const float a = 0.224282f;
            const float b = 155.975327f;
            const float c = 0.01f;
            const float g = 15.1927f;

            if (in < 0.0f) {
                return (in / g) - c;
            } else {
                return (powf(10.0f, in / a) - 1.0f) / b - c;
            }
        }
        case Sony_S_Log3:
        {
            // Sony S-Log3 to Linear
            const float cut1 = 171.2102947f / 1023.0f;
            const float a    = 10.0f;
            const float b    = 0.19f;
            const float c    = -0.01f;
            const float d    = 0.01125f;
            const float e    = 95.0f;
            const float f    = 171.2102947f;
            const float denom = f - e;

            if (in >= cut1) {
                float num = in * 1023.0f - 420.0f;
                float exponent = num / 261.5f;
                return powf(a, exponent) * b + c;
            } else {
                float num = in * 1023.0f - e;
                return num * d / denom;
            }
        }
        case Rec709:
        {
            // Rec.709 to Linear
            if (in < 0.081f) {
                return in / 4.5f;
            } else {
                return powf((in + 0.099f) / 1.099f, 1.0f / 0.45f);
            }
        }
        case Gamma_2_2:
        {
            // Gamma 2.2 to Linear
            return powf(in, 2.2f);
        }
        case Gamma_2_4:
        {
            // Gamma 2.4 to Linear
            return powf(in, 2.4f);
        }
        case Gamma_2_6:
        {
            // Gamma 2.6 to Linear
            return powf(in, 2.6f);
        }
        case Linear:
        default:
        {
            // Linear (no conversion)
            return in;
        }
    }
}

__DEVICE__ float linear_to_gamma(float in, GammaType gamma_type) {
    switch (gamma_type) {
        case ACEScc:
        {
            // Linear to ACEScc
            const float a   = 17.52f;
            const float b   = 9.72f;
            const float c   = powf(2.0f, -16.0f);
            const float cut = c * 0.5f;

            if (in <= 0.0f) {
                return (-16.0f + b) / a;
            } else if (in < cut) {
                return (_log2f(c + in * 0.5f) + b) / a;
            } else {
                return (_log2f(in) + b) / a;
            }
        }
        case ACEScct:
        {
            // Linear to ACEScct
            const float a  = 17.52f;
            const float b  = 9.72f;
            const float m  = 10.5402377416545f;
            const float k0 = 0.0729055341958355f;
            const float c1 = 0.0078125f;

            if (in <= c1) {
                return m * in + k0;
            } else {
                return (_log2f(in) + b) / a;
            }
        }
        case ARRI_LogC3:
        {
            // Linear to ARRI LogC3
            const float a   = 5.555556f;
            const float b   = 0.052272f;
            const float c   = 0.247190f;
            const float d   = 0.385537f;
            const float e   = 5.367655f;
            const float f   = 0.092809f;
            const float cut = 0.010591f;

            if (in > cut) {
                return c * _log10f(a * in + b) + d;
            } else {
                return e * in + f;
            }
        }
        case ARRI_LogC4:
        {
            // Linear to ARRI LogC4
            const float a   = 2231.91177f;
            const float b   = 0.9070295f;
            const float c   = 0.0929705f;
            const float s   = 0.11343535f;
            const float t   = -0.01807264f;

            if (in < t) {
                return (in - t) / s;
            } else {
                return ((_log2f(a * in + 64.0f) - 6.0f) / 14.0f) * b + c;
            }
        }
        case Apple_Log:
        {
            // Linear to Apple Log
            const float R0 = -0.05641088f;
            const float Rt = 0.01f;
            const float c  = 47.28711236f;
            const float b  = 0.00964052f;
            const float y  = 0.08550479f;
            const float d  = 0.69336945f;

            if (in >= Rt) {
                return y * _log2f(in + b) + d;
            } else if (in > R0) {
                return c * powf(in - R0, 2.0f);
            } else {
                return 0.0f;
            }
        }
        case DaVinci_Intermediate:
        {
            // Linear to DaVinci Intermediate
            const float A       = 0.0075f;
            const float B       = 7.0f;
            const float C       = 0.07329248f;
            const float M       = 10.44426855f;
            const float lin_cut = 0.00262409f;

            if (in > lin_cut) {
                return (_log2f(in + A) + B) * C;
            } else {
                return in * M;
            }
        }
        case Fuji_F_Log:
        {
            // Linear to Fuji F-Log
            const float a   = 0.555556f;
            const float b   = 0.009468f;
            const float c   = 0.344676f;
            const float d   = 0.790453f;
            const float e   = 8.735631f;
            const float f   = 0.092864f;
            const float cut = 0.00089f;

            if (in >= cut) {
                return c * _log10f(a * in + b) + d;
            } else {
                return e * in + f;
            }
        }
        case Fuji_F_Log2:
        {
            // Linear to Fuji F-Log2
            const float a   = 5.555556f;
            const float b   = 0.064829f;
            const float c   = 0.245281f;
            const float d   = 0.384316f;
            const float e   = 8.799461f;
            const float f   = 0.092864f;
            const float cut = 0.000889f;

            if (in >= cut) {
                return c * _log10f(a * in + b) + d;
            } else {
                return e * in + f;
            }
        }
        case RED_Log3G10:
        {
            // Linear to RED Log3G10
            const float a = 0.224282f;
            const float b = 155.975327f;
            const float c = 0.01f;
            const float g = 15.1927f;

            in = in + c;

            if (in < 0.0f) {
                return in * g;
            } else {
                return a * _log10f(in * b + 1.0f);
            }
        }
        case Sony_S_Log3:
        {
            // Linear to Sony S-Log3
            const float cut2 = 0.01125f;
            const float a    = 420.0f;
            const float b    = 261.5f;
            const float c    = 0.19f;
            const float d    = 95.0f;
            const float e    = 171.2102947f;
            const float denom = 0.01125f;
            const float num_factor = e - d;

            if (in >= cut2) {
                return (a + _log10f((in + 0.01f) / c) * b) / 1023.0f;
            } else {
                return (in * num_factor / denom + d) / 1023.0f;
            }
        }
        case Rec709:
        {
            // Linear to Rec.709
            if (in < 0.018f) {
                return 4.5f * in;
            } else {
                return 1.099f * powf(in, 0.45f) - 0.099f;
            }
        }
        case Gamma_2_2:
        {
            // Linear to Gamma 2.2
            return powf(in, 1.0f / 2.2f);
        }
        case Gamma_2_4:
        {
            // Linear to Gamma 2.4
            return powf(in, 1.0f / 2.4f);
        }
        case Gamma_2_6:
        {
            // Linear to Gamma 2.6
            return powf(in, 1.0f / 2.6f);
        }
        case Linear:
        default:
        {
            // Linear (no conversion)
            return in;
        }
    }
}


// ===============================
// SECTION 4: 🧩 Applying OOTF
// ===============================

__DEVICE__ float3 apply_forward_ootf(float3 in) {
    // Step 1: Convert linear light to rec709 gamma curve (not gamma 2.4)
    in.x = linear_to_gamma(in.x, Rec709);
    in.y = linear_to_gamma(in.y, Rec709);
    in.z = linear_to_gamma(in.z, Rec709);

    // Step 2: Convert rec709 gamma curve to linear light as if it were gamma 2.4
    in.x = gamma_to_linear(in.x, Gamma_2_4);
    in.y = gamma_to_linear(in.y, Gamma_2_4);
    in.z = gamma_to_linear(in.z, Gamma_2_4);

    return in;
}

__DEVICE__ float3 apply_inverse_ootf(float3 in) {
    // Step 1: Convert linear light to gamma 2.4
    in.x = linear_to_gamma(in.x, Gamma_2_4);
    in.y = linear_to_gamma(in.y, Gamma_2_4);
    in.z = linear_to_gamma(in.z, Gamma_2_4);

    // Step 2: Convert gamma 2.4 to linear light as if it were rec709 gamma curve
    in.x = gamma_to_linear(in.x, Rec709);
    in.y = gamma_to_linear(in.y, Rec709);
    in.z = gamma_to_linear(in.z, Rec709);

    return in;
}


// ===============================
// SECTION 5: 🌈 Color Space Transformation Matrices
// Reference: https://haraldbrendel.com/colorspacecalculator.html
// Reference: https://www.colour-science.org:8010/apps/rgb_colourspace_transformation_matrix
// Note: These matrices use CAT02 white point adaptation.
// ===============================

__CONSTANT__ float input_to_xyz_matrices[15][3][3] = {
    // ACES (AP0) to XYZ
    {
        { 0.9865190867f,  0.0239710338f, -0.0104901205f },
        { 0.3596892056f,  0.7145861558f, -0.0742753614f },
        {-0.0003859199f,  0.0000294397f,  1.0003564803f }
    },
    // ACES (AP1) to XYZ
    {
        { 0.6872086492f,  0.1593471996f,  0.1534441512f },
        { 0.2825666760f,  0.6646107144f,  0.0528226096f },
        {-0.0057949226f,  0.0039976629f,  1.0017972596f }
    },
    // Apple Wide Gamut RGB to XYZ
    {
        { 0.6708365530f,  0.1770960214f,  0.1520674256f },
        { 0.2767901798f,  0.6703353325f,  0.0528744876f },
        {-0.0007465395f,  0.0250331578f,  0.9757133817f }
    },
    // ARRI Wide Gamut 3 to XYZ
    {
        { 0.6730620361f,  0.2579995230f,  0.0689385104f },
        { 0.3055464219f,  0.8166532038f, -0.1221996261f },
        { 0.0017970073f, -0.0626457618f,  1.0608489836f }
    },
    // ARRI Wide Gamut 4 to XYZ
    {
        { 0.7408587166f,  0.1666331576f,  0.0925081259f },
        { 0.2707356648f,  0.7718831293f, -0.0426187940f },
        {-0.0007899156f, -0.0008805599f,  1.0016704755f }
    },
    // DaVinci Wide Gamut to XYZ
    {
        { 0.7396425052f,  0.1934275669f,  0.0669299278f },
        { 0.2908353452f,  0.8643581278f, -0.1551934730f },
        {-0.0918330386f, -0.1278242346f,  1.2196572732f }
    },
    // Fuji F-Gamut to XYZ
    {
        { 0.6708365530f,  0.1770960214f,  0.1520674256f },
        { 0.2767901798f,  0.6703353325f,  0.0528744876f },
        {-0.0007465395f,  0.0250331578f,  0.9757133817f }
    },
    // REDWideGamutRGB to XYZ
    {
        { 0.7756070000f,  0.1141060000f,  0.1102870000f },
        { 0.3040190000f,  0.8339320000f, -0.1379510000f },
        {-0.0741360000f, -0.3203840000f,  1.3945200000f }
    },
    // Sony S-Gamut3.Cine to XYZ
    {
        { 0.6303970000f,  0.2950390000f,  0.0745640000f },
        { 0.2291890000f,  0.8774470000f, -0.1066360000f },
        {-0.0301650000f, -0.0265150000f,  1.0566800000f }
    },
    // P3-DCI to XYZ
    {
        { 0.4802766516f,  0.3389944515f,  0.1807288968f },
        { 0.2223252150f,  0.7054675346f,  0.0722072505f },
        {-0.0000834022f,  0.0498315836f,  0.9502518187f }
    },
    // P3-D60 to XYZ
    {
        { 0.5247750000f,  0.2932950000f,  0.1819300000f },
        { 0.2449270000f,  0.6823140000f,  0.0727590000f },
        {-0.0002020000f,  0.0444860000f,  0.9557170000f }
    },
    // P3-D65 to XYZ
    {
        { 0.5136157546f,  0.3026880210f,  0.1836962244f },
        { 0.2392533032f,  0.6872070291f,  0.0735396677f },
        {-0.0005985984f,  0.0406016281f,  0.9599969704f }
    },
    // Rec.2020 to XYZ
    {
        { 0.6708365530f,  0.1770960214f,  0.1520674256f },
        { 0.2767901798f,  0.6703353325f,  0.0528744876f },
        {-0.0007465395f,  0.0250331578f,  0.9757133817f }
    },
    // Rec.709 to XYZ
    {
        { 0.4356149258f,  0.3971260011f,  0.1672590731f },
        { 0.2208442806f,  0.7121963865f,  0.0669593329f },
        { 0.0172546878f,  0.1086489393f,  0.8740963729f }
    },
    // XYZ (CIE) to XYZ
    {
        { 1.0000000000f,  0.0000000000f,  0.0000000000f },
        { 0.0000000000f,  1.0000000000f,  0.0000000000f },
        { 0.0000000000f,  0.0000000000f,  1.0000000000f }
    }
};

__CONSTANT__ float xyz_to_output_matrices[15][3][3] = {
    // XYZ to ACES (AP0)
    {
        { 1.0262199329f, -0.0344252321f,  0.0082052992f },
        {-0.5165083244f,  1.4167337178f,  0.0997746067f },
        { 0.0004110980f, -0.0000549739f,  0.9996438760f }
    },
    // XYZ to ACES (AP1)
    {
        { 1.6115673705f, -0.3850270695f, -0.2265403009f },
        {-0.6861344162f,  1.6690451366f,  0.0170892795f },
        { 0.0120601670f, -0.0088875088f,  0.9968273418f }
    },
    // XYZ to Apple Wide Gamut RGB
    {
        { 1.6686603449f, -0.4320060262f, -0.2366543187f },
        {-0.6905096596f,  1.6735845014f,  0.0169251582f },
        { 0.0189926248f, -0.0432684590f,  1.0242758342f }
    },
    // XYZ to ARRI Wide Gamut 3
    {
        { 1.7423079482f, -0.5641048766f, -0.1782030065f },
        {-0.6581319753f,  1.4485090587f,  0.2096223187f },
        {-0.0418166533f,  0.0864936944f,  0.9553216307f }
    },
    // XYZ to ARRI Wide Gamut 4
    {
        { 1.4652841412f, -0.3164934342f, -0.1487907070f },
        {-0.5139051082f,  1.4065965188f,  0.1073085894f },
        { 0.0007037509f,  0.0009869408f,  0.9983093083f }
    },
    // XYZ to DaVinci Wide Gamut
    {
        { 1.4733912075f, -0.3482276629f, -0.1251635447f },
        {-0.4849671842f,  1.2937347658f,  0.1912324184f },
        { 0.0601115035f,  0.1093683076f,  0.8305201889f }
    },
    // XYZ to Fuji F-Gamut
    {
        { 1.6686603449f, -0.4320060262f, -0.2366543187f },
        {-0.6905096596f,  1.6735845014f,  0.0169251582f },
        { 0.0189926248f, -0.0432684590f,  1.0242758342f }
    },
    // XYZ to REDWideGamutRGB
    {
        { 1.3700500000f, -0.2381400000f, -0.1319100000f },
        {-0.5066740000f,  1.3345810000f,  0.1720930000f },
        {-0.0435710000f,  0.2939530000f,  0.7496170000f }
    },
    // XYZ to Sony S-Gamut3.Cine
    {
        { 1.7993090000f, -0.6107120000f, -0.1885970000f },
        {-0.4651540000f,  1.3010360000f,  0.1641180000f },
        { 0.0396920000f,  0.0152130000f,  0.9450950000f }
    },
    // XYZ to P3-DCI
    {
        { 2.6604007802f, -1.2493529403f, -0.4110478399f },
        {-0.8429629296f,  1.8210136172f,  0.0219493124f },
        { 0.0444388111f, -0.0956043327f,  1.0511655217f }
    },
    // XYZ to P3-D60
    {
        { 2.3693620000f, -0.9940050000f, -0.3753570000f },
        {-0.8548150000f,  1.8315280000f,  0.0232870000f },
        { 0.0402900000f, -0.0854620000f,  1.0451720000f }
    },
    // XYZ to P3-D65
    {
        { 2.4356574184f, -1.0500288030f, -0.3856286154f },
        {-0.8520004591f,  1.8290847820f,  0.0229156770f },
        { 0.0375528128f, -0.0780131271f,  1.0404603143f }
    },
    // XYZ to Rec.2020
    {
        { 1.6686603449f, -0.4320060262f, -0.2366543187f },
        {-0.6905096596f,  1.6735845014f,  0.0169251582f },
        { 0.0189926248f, -0.0432684590f,  1.0242758342f }
    },
    // XYZ to Rec.709
    {
        { 3.1751837609f, -1.6976571204f, -0.4775266405f },
        {-0.9902693375f,  1.9501715317f,  0.0400978058f },
        { 0.0604108543f, -0.2088917543f,  1.1484809000f }
    },
    // XYZ to XYZ (CIE)
    {
        { 1.0000000000f,  0.0000000000f,  0.0000000000f },
        { 0.0000000000f,  1.0000000000f,  0.0000000000f },
        { 0.0000000000f,  0.0000000000f,  1.0000000000f }
    }
};


// ===============================
// SECTION 6: 🌵 Main Function
// ===============================

__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y, float p_R, float p_G, float p_B) {
    // Initialize output color
    float3 out = make_float3(p_R, p_G, p_B);

    // Step 1: Input gamma --> linear light
    out.x = gamma_to_linear(out.x, (GammaType)input_gamma);
    out.y = gamma_to_linear(out.y, (GammaType)input_gamma);
    out.z = gamma_to_linear(out.z, (GammaType)input_gamma);

    // Step 2: Inverse OOTF 
    if (inverse_ootf) {
        out = apply_inverse_ootf(out);
    }

    // Step 3: Input color space --> XYZ
    __CONSTANT__ float (*matrix_in)[3] = input_to_xyz_matrices[input_color_space];
    float3 xyz;
    xyz.x = out.x * matrix_in[0][0] + out.y * matrix_in[0][1] + out.z * matrix_in[0][2];
    xyz.y = out.x * matrix_in[1][0] + out.y * matrix_in[1][1] + out.z * matrix_in[1][2];
    xyz.z = out.x * matrix_in[2][0] + out.y * matrix_in[2][1] + out.z * matrix_in[2][2];

    // Step 4: XYZ --> output color space
    __CONSTANT__ float (*matrix_out)[3] = xyz_to_output_matrices[output_color_space];
    out.x = xyz.x * matrix_out[0][0] + xyz.y * matrix_out[0][1] + xyz.z * matrix_out[0][2];
    out.y = xyz.x * matrix_out[1][0] + xyz.y * matrix_out[1][1] + xyz.z * matrix_out[1][2];
    out.z = xyz.x * matrix_out[2][0] + xyz.y * matrix_out[2][1] + xyz.z * matrix_out[2][2];

    // Step 5: Forward OOTF
    if (forward_ootf) {
        out = apply_forward_ootf(out);
    }
    
    // Step 6: Linear light --> output gamma
    out.x = linear_to_gamma(out.x, (GammaType)output_gamma);
    out.y = linear_to_gamma(out.y, (GammaType)output_gamma);
    out.z = linear_to_gamma(out.z, (GammaType)output_gamma);

    // Return the transformed color
    return out;
}