Add high-precision GPU trilinear interpolation for 3D LUTs.

cessen · cessen · commit 2fbaf7501e73 · 2023-04-26T18:52:51.000+02:00
This new code path can be enabled by disabling the new default-enabled
OPTIMIZATION_NATIVE_GPU_TRILINEAR optimization flag.

The existing code path used the GPU's native trilinear texture
interpolation function, which, although faster, quantized the lookup
coordinates which could cause banding.  That's still the default,
but full-precision trilinear interpolation can optionally be used
instead.

Signed-off-by: Nathan Vegdahl &lt;cessen@cessen.com&gt;
diff --git a/include/OpenColorIO/OpenColorTypes.h b/include/OpenColorIO/OpenColorTypes.h
@@ -619,6 +619,13 @@ enum OptimizationFlags : unsigned long
      */
     OPTIMIZATION_NO_DYNAMIC_PROPERTIES           = 0x10000000,
 
+    /**
+     * For GPU processor, use native trilinear interpolation for 3D LUTs.  This is faster,
+     * but on many GPUs also lower precision.  With low-resolution LUTs, LUTs with large
+     * extents, or LUTs applied in a linear color space this can sometimes cause color banding.
+     */
+    OPTIMIZATION_NATIVE_GPU_TRILINEAR            = 0x20000000,
+
     /// Apply all possible optimizations.
     OPTIMIZATION_ALL                             = 0xFFFFFFFF,
 
@@ -645,6 +652,7 @@ enum OptimizationFlags : unsigned long
                               OPTIMIZATION_COMP_LUT1D |
                               OPTIMIZATION_LUT_INV_FAST |
                               OPTIMIZATION_FAST_LOG_EXP_POW |
+                              OPTIMIZATION_NATIVE_GPU_TRILINEAR |
                               OPTIMIZATION_COMP_SEPARABLE_PREFIX),
 
     OPTIMIZATION_GOOD      = OPTIMIZATION_VERY_GOOD | OPTIMIZATION_COMP_LUT3D,
diff --git a/src/OpenColorIO/GPUProcessor.cpp b/src/OpenColorIO/GPUProcessor.cpp
@@ -85,6 +85,9 @@ void GPUProcessor::Impl::finalize(const OpRcPtrVec & rawOps, OptimizationFlags o
     // Is NoOp ?
     m_isNoOp  = m_ops.isNoOp();
 
+    // Store optimization flags for use when generating shader code.
+    m_oFlags = oFlags;
+
     // Does the color processing introduce crosstalk between the pixel channels?
     m_hasChannelCrosstalk = m_ops.hasChannelCrosstalk();
 
@@ -104,7 +107,7 @@ void GPUProcessor::Impl::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCrea
     // Create the shader program information.
     for(const auto & op : m_ops)
     {
-        op->extractGpuShaderInfo(shaderCreator);
+        op->extractGpuShaderInfo(shaderCreator, m_oFlags);
     }
 
     WriteShaderHeader(shaderCreator);
diff --git a/src/OpenColorIO/GPUProcessor.h b/src/OpenColorIO/GPUProcessor.h
@@ -41,6 +41,7 @@ class GPUProcessor::Impl
     OpRcPtrVec    m_ops;
     bool          m_isNoOp = false;
     bool          m_hasChannelCrosstalk = true;
+    OptimizationFlags m_oFlags = OPTIMIZATION_DEFAULT;
     std::string   m_cacheID;
     mutable Mutex m_mutex;
 };
diff --git a/src/OpenColorIO/Op.h b/src/OpenColorIO/Op.h
@@ -246,7 +246,7 @@ class Op
     virtual bool supportedByLegacyShader() const { return true; }
 
     // Create & add the gpu shader information needed by the op. Op has to be finalized.
-    virtual void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const = 0;
+    virtual void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags oFlags = OPTIMIZATION_DEFAULT) const = 0;
 
     virtual bool isDynamic() const;
     virtual bool hasDynamicProperty(DynamicPropertyType type) const;
diff --git a/src/OpenColorIO/ops/cdl/CDLOp.cpp b/src/OpenColorIO/ops/cdl/CDLOp.cpp
@@ -50,7 +50,7 @@ class CDLOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstCDLOpDataRcPtr cdlData() const { return DynamicPtrCast<const CDLOpData>(data()); }
@@ -133,7 +133,7 @@ ConstOpCPURcPtr CDLOp::getCPUOp(bool fastLogExpPow) const
     return GetCDLCPURenderer(data, fastLogExpPow);
 }
 
-void CDLOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void CDLOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstCDLOpDataRcPtr data = cdlData();
     GetCDLGPUShaderProgram(shaderCreator, data);
diff --git a/src/OpenColorIO/ops/exponent/ExponentOp.cpp b/src/OpenColorIO/ops/exponent/ExponentOp.cpp
@@ -150,7 +150,7 @@ class ExponentOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstExponentOpDataRcPtr expData() const { return DynamicPtrCast<const ExponentOpData>(data()); }
@@ -251,7 +251,7 @@ ConstOpCPURcPtr ExponentOp::getCPUOp(bool /*fastLogExpPow*/) const
     return std::make_shared<ExponentOpCPU>(expData());
 }
 
-void ExponentOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void ExponentOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     GpuShaderText ss(shaderCreator->getLanguage());
     ss.indent();
diff --git a/src/OpenColorIO/ops/exposurecontrast/ExposureContrastOp.cpp b/src/OpenColorIO/ops/exposurecontrast/ExposureContrastOp.cpp
@@ -49,7 +49,7 @@ class ExposureContrastOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstExposureContrastOpDataRcPtr ecData() const
@@ -135,7 +135,7 @@ ConstOpCPURcPtr ExposureContrastOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetExposureContrastCPURenderer(ecOpData);
 }
 
-void ExposureContrastOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void ExposureContrastOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstExposureContrastOpDataRcPtr ecOpData = ecData();
     GetExposureContrastGPUShaderProgram(shaderCreator, ecOpData);
diff --git a/src/OpenColorIO/ops/fixedfunction/FixedFunctionOp.cpp b/src/OpenColorIO/ops/fixedfunction/FixedFunctionOp.cpp
@@ -45,7 +45,7 @@ class FixedFunctionOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstFixedFunctionOpDataRcPtr fnData() const { return DynamicPtrCast<const FixedFunctionOpData>(data()); }
@@ -125,7 +125,7 @@ ConstOpCPURcPtr FixedFunctionOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetFixedFunctionCPURenderer(data);
 }
 
-void FixedFunctionOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void FixedFunctionOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstFixedFunctionOpDataRcPtr fnOpData = fnData();
     GetFixedFunctionGPUShaderProgram(shaderCreator, fnOpData);
diff --git a/src/OpenColorIO/ops/gamma/GammaOp.cpp b/src/OpenColorIO/ops/gamma/GammaOp.cpp
@@ -44,7 +44,7 @@ class GammaOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstGammaOpDataRcPtr gammaData() const { return DynamicPtrCast<const GammaOpData>(data()); }
@@ -123,7 +123,7 @@ ConstOpCPURcPtr GammaOp::getCPUOp(bool fastLogExpPow) const
     return GetGammaRenderer(data, fastLogExpPow);
 }
 
-void GammaOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void GammaOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstGammaOpDataRcPtr data = gammaData();
     GetGammaGPUShaderProgram(shaderCreator, data);
diff --git a/src/OpenColorIO/ops/gradingprimary/GradingPrimaryOp.cpp b/src/OpenColorIO/ops/gradingprimary/GradingPrimaryOp.cpp
@@ -52,7 +52,7 @@ class GradingPrimaryOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstGradingPrimaryOpDataRcPtr primaryData() const
@@ -190,7 +190,7 @@ ConstOpCPURcPtr GradingPrimaryOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetGradingPrimaryCPURenderer(data);
 }
 
-void GradingPrimaryOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void GradingPrimaryOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstGradingPrimaryOpDataRcPtr data = primaryData();
     GetGradingPrimaryGPUShaderProgram(shaderCreator, data);
diff --git a/src/OpenColorIO/ops/gradingrgbcurve/GradingRGBCurveOp.cpp b/src/OpenColorIO/ops/gradingrgbcurve/GradingRGBCurveOp.cpp
@@ -52,7 +52,7 @@ class GradingRGBCurveOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstGradingRGBCurveOpDataRcPtr rgbCurveData() const
@@ -190,7 +190,7 @@ ConstOpCPURcPtr GradingRGBCurveOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetGradingRGBCurveCPURenderer(data);
 }
 
-void GradingRGBCurveOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void GradingRGBCurveOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstGradingRGBCurveOpDataRcPtr data = rgbCurveData();
     GetGradingRGBCurveGPUShaderProgram(shaderCreator, data);
diff --git a/src/OpenColorIO/ops/gradingtone/GradingToneOp.cpp b/src/OpenColorIO/ops/gradingtone/GradingToneOp.cpp
@@ -52,7 +52,7 @@ class GradingToneOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstGradingToneOpDataRcPtr toneData() const
@@ -184,7 +184,7 @@ ConstOpCPURcPtr GradingToneOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetGradingToneCPURenderer(data);
 }
 
-void GradingToneOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void GradingToneOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstGradingToneOpDataRcPtr data = toneData();
     GetGradingToneGPUShaderProgram(shaderCreator, data);
diff --git a/src/OpenColorIO/ops/log/LogOp.cpp b/src/OpenColorIO/ops/log/LogOp.cpp
@@ -44,7 +44,7 @@ class LogOp: public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstLogOpDataRcPtr logData() const { return DynamicPtrCast<const LogOpData>(data()); }
@@ -110,7 +110,7 @@ ConstOpCPURcPtr LogOp::getCPUOp(bool fastLogExpPow) const
     return GetLogRenderer(data, fastLogExpPow);
 }
 
-void LogOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void LogOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstLogOpDataRcPtr data = logData();
     GetLogGPUShaderProgram(shaderCreator, data);
diff --git a/src/OpenColorIO/ops/lut1d/Lut1DOp.cpp b/src/OpenColorIO/ops/lut1d/Lut1DOp.cpp
@@ -52,7 +52,7 @@ class Lut1DOp : public Op
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
     bool supportedByLegacyShader() const override { return false; }
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
     ConstLut1DOpDataRcPtr lut1DData() const { return DynamicPtrCast<const Lut1DOpData>(data()); }
     Lut1DOpDataRcPtr lut1DData() { return DynamicPtrCast<Lut1DOpData>(data()); }
@@ -154,7 +154,7 @@ ConstOpCPURcPtr Lut1DOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetLut1DRenderer(data, BIT_DEPTH_F32, BIT_DEPTH_F32);
 }
 
-void Lut1DOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void Lut1DOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstLut1DOpDataRcPtr lutData = lut1DData();
     if (lutData->getDirection() == TRANSFORM_DIR_INVERSE)
diff --git a/src/OpenColorIO/ops/lut3d/Lut3DOp.cpp b/src/OpenColorIO/ops/lut3d/Lut3DOp.cpp
@@ -98,7 +98,7 @@ class Lut3DOp : public Op
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
     bool supportedByLegacyShader() const override { return false; }
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags oFlags) const override;
 
 protected:
     ConstLut3DOpDataRcPtr lut3DData() const
@@ -200,7 +200,7 @@ ConstOpCPURcPtr Lut3DOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetLut3DRenderer(data);
 }
 
-void Lut3DOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void Lut3DOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags oFlags) const
 {
     ConstLut3DOpDataRcPtr lutData = lut3DData();
     if (lutData->getDirection() == TRANSFORM_DIR_INVERSE)
@@ -216,7 +216,7 @@ void Lut3DOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
         lutData = tmp;
     }
 
-    GetLut3DGPUShaderProgram(shaderCreator, lutData);
+    GetLut3DGPUShaderProgram(shaderCreator, lutData, oFlags);
 }
 }
 
diff --git a/src/OpenColorIO/ops/lut3d/Lut3DOpGPU.cpp b/src/OpenColorIO/ops/lut3d/Lut3DOpGPU.cpp
@@ -14,7 +14,7 @@
 namespace OCIO_NAMESPACE
 {
 
-void GetLut3DGPUShaderProgram(GpuShaderCreatorRcPtr & shaderCreator, ConstLut3DOpDataRcPtr & lutData)
+void GetLut3DGPUShaderProgram(GpuShaderCreatorRcPtr & shaderCreator, ConstLut3DOpDataRcPtr & lutData, OptimizationFlags oFlags)
 {
 
     if (shaderCreator->getLanguage() == LANGUAGE_OSL_1)
@@ -32,9 +32,11 @@ void GetLut3DGPUShaderProgram(GpuShaderCreatorRcPtr & shaderCreator, ConstLut3DO
     std::string name(resName.str());
     StringUtils::ReplaceInPlace(name, "__", "_");
 
+    const bool use_high_precision = !HasFlag(oFlags, OPTIMIZATION_NATIVE_GPU_TRILINEAR);
     Interpolation samplerInterpolation = lutData->getConcreteInterpolation();
-    // Enforce GL_NEAREST with shader-generated tetrahedral interpolation.
-    if (samplerInterpolation == INTERP_TETRAHEDRAL)
+    // Enforce GL_NEAREST with shader-generated tetrahedral interpolation
+    // or hand-rolled trilinear interpolation.
+    if (samplerInterpolation == INTERP_TETRAHEDRAL || use_high_precision)
     {
         samplerInterpolation = INTERP_NEAREST;
     }
@@ -225,18 +227,72 @@ void GetLut3DGPUShaderProgram(GpuShaderCreatorRcPtr & shaderCreator, ConstLut3DO
         else
         {
             // Trilinear interpolation
-            // Use texture3d and GL_LINEAR and the GPU's built-in trilinear algorithm.
-            // Note that the fractional components are quantized to 8-bits on some
-            // hardware, which introduces significant error with small grid sizes.
-
-            ss.newLine() << ss.float3Decl(name + "_coords")
-                         << " = (" << shaderCreator->getPixelName() << ".zyx * "
-                         << ss.float3Const(dim - 1) << " + "
-                         << ss.float3Const(0.5f) + ") / "
-                         << ss.float3Const(dim) << ";";
-
-            ss.newLine() << shaderCreator->getPixelName() << ".rgb = "
-                         << ss.sampleTex3D(name, name + "_coords") << ".rgb;";
+            if (use_high_precision)
+            {
+                // Use GL_NEAREST and do interpolation by hand to avoid the precision
+                // issues of native trilinear interpolation on many popular GPUs.
+
+                ss.newLine() << ss.float3Decl("coords") << " = "
+                             << shaderCreator->getPixelName() << ".rgb * "
+                             << ss.float3Const(dim - 1) << "; ";
+
+                // baseInd is on [0,dim-1]
+                ss.newLine() << ss.float3Decl("baseInd") << " = floor(coords);";
+
+                // frac is on [0,1]
+                ss.newLine() << ss.float3Decl("frac") << " = coords - baseInd;";
+
+                // Scale/offset baseInd onto [0,1] as usual for doing texture lookups.
+                // We use zyx to flip the order since blue varies most rapidly
+                // in the grid array ordering.
+                ss.newLine() << "baseInd = ( baseInd.zyx + " << ss.float3Const(0.5f) << " ) / " << ss.float3Const(dim) << ";";
+
+                // Fetch the 8 corners of the 3D texture cell.
+                ss.newLine() << ss.float3Decl("nextInd") << " = baseInd;";
+                ss.newLine() << ss.float3Decl("v1") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+                ss.newLine() << "nextInd = baseInd + " << ss.float3Const(incr, 0.0f, 0.0f) << ";";
+                ss.newLine() << ss.float3Decl("v2") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+                ss.newLine() << "nextInd = baseInd + " << ss.float3Const(0.0f, incr, 0.0f) << ";";
+                ss.newLine() << ss.float3Decl("v3") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+                ss.newLine() << "nextInd = baseInd + " << ss.float3Const(incr, incr, 0.0f) << ";";
+                ss.newLine() << ss.float3Decl("v4") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+                ss.newLine() << "nextInd = baseInd + " << ss.float3Const(0.0f, 0.0f, incr) << ";";
+                ss.newLine() << ss.float3Decl("v5") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+                ss.newLine() << "nextInd = baseInd + " << ss.float3Const(incr, 0.0f, incr) << ";";
+                ss.newLine() << ss.float3Decl("v6") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+                ss.newLine() << "nextInd = baseInd + " << ss.float3Const(0.0f, incr, incr) << ";";
+                ss.newLine() << ss.float3Decl("v7") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+                ss.newLine() << "nextInd = baseInd + " << ss.float3Const(incr, incr, incr) << ";";
+                ss.newLine() << ss.float3Decl("v8") << " = " << ss.sampleTex3D(name, "nextInd") << ".rgb;";
+
+                // Lerp on Z.
+                ss.newLine() << ss.float3Decl("v1_2") << " = " << ss.lerp("v1", "v2", "frac.z") << ";";
+                ss.newLine() << ss.float3Decl("v3_4") << " = " << ss.lerp("v3", "v4", "frac.z") << ";";
+                ss.newLine() << ss.float3Decl("v5_6") << " = " << ss.lerp("v5", "v6", "frac.z") << ";";
+                ss.newLine() << ss.float3Decl("v7_8") << " = " << ss.lerp("v7", "v8", "frac.z") << ";";
+
+                // Lerp on Y.
+                ss.newLine() << ss.float3Decl("v1_2_3_4") << " = " << ss.lerp("v1_2", "v3_4", "frac.y") << ";";
+                ss.newLine() << ss.float3Decl("v5_6_7_8") << " = " << ss.lerp("v5_6", "v7_8", "frac.y") << ";";
+
+                // Lerp on X.
+                ss.newLine() << shaderCreator->getPixelName() << ".rgb = " << ss.lerp("v1_2_3_4", "v5_6_7_8", "frac.x") << ";";
+            }
+            else
+            {
+                // Use texture3d and GL_LINEAR and the GPU's built-in trilinear algorithm.
+                // Note that the fractional components are quantized to 8-bits on some
+                // hardware, which introduces significant error with small grid sizes.
+
+                ss.newLine() << ss.float3Decl(name + "_coords")
+                             << " = (" << shaderCreator->getPixelName() << ".zyx * "
+                             << ss.float3Const(dim - 1) << " + "
+                             << ss.float3Const(0.5f) + ") / "
+                             << ss.float3Const(dim) << ";";
+
+                ss.newLine() << shaderCreator->getPixelName() << ".rgb = "
+                             << ss.sampleTex3D(name, name + "_coords") << ".rgb;";
+            }
         }
 
         shaderCreator->addToFunctionShaderCode(ss.string().c_str());
diff --git a/src/OpenColorIO/ops/lut3d/Lut3DOpGPU.h b/src/OpenColorIO/ops/lut3d/Lut3DOpGPU.h
@@ -12,7 +12,7 @@
 namespace OCIO_NAMESPACE
 {
 
-void GetLut3DGPUShaderProgram(GpuShaderCreatorRcPtr & shaderCreator, ConstLut3DOpDataRcPtr & lutData);
+void GetLut3DGPUShaderProgram(GpuShaderCreatorRcPtr & shaderCreator, ConstLut3DOpDataRcPtr & lutData, OptimizationFlags oFlags);
 
 } // namespace OCIO_NAMESPACE
 
diff --git a/src/OpenColorIO/ops/matrix/MatrixOp.cpp b/src/OpenColorIO/ops/matrix/MatrixOp.cpp
@@ -62,7 +62,7 @@ class MatrixOffsetOp : public Op
 
     ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;
 
-    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;
+    void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const override;
 
 protected:
     ConstMatrixOpDataRcPtr matrixData() const { return DynamicPtrCast<const MatrixOpData>(data()); }
@@ -187,7 +187,7 @@ ConstOpCPURcPtr MatrixOffsetOp::getCPUOp(bool /*fastLogExpPow*/) const
     return GetMatrixRenderer(data);
 }
 
-void MatrixOffsetOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const
+void MatrixOffsetOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /*oFlags*/) const
 {
     ConstMatrixOpDataRcPtr data = matrixData();
     if (data->getDirection() == TRANSFORM_DIR_INVERSE)
diff --git a/src/OpenColorIO/ops/noop/NoOps.cpp b/src/OpenColorIO/ops/noop/NoOps.cpp
diff --git a/src/OpenColorIO/ops/range/RangeOp.cpp b/src/OpenColorIO/ops/range/RangeOp.cpp

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ class CDLOp : public Op`
`50`	`50`
`51`	`51`	`ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;`
`52`	`52`
`53`		`- void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;`
	`53`	`+ void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const override;`
`54`	`54`
`55`	`55`	`protected:`
`56`	`56`	`ConstCDLOpDataRcPtr cdlData() const { return DynamicPtrCast<const CDLOpData>(data()); }`
`@@ -133,7 +133,7 @@ ConstOpCPURcPtr CDLOp::getCPUOp(bool fastLogExpPow) const`
`133`	`133`	`return GetCDLCPURenderer(data, fastLogExpPow);`
`134`	`134`	`}`
`135`	`135`
`136`		`-void CDLOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const`
	`136`	`+void CDLOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const`
`137`	`137`	`{`
`138`	`138`	`ConstCDLOpDataRcPtr data = cdlData();`
`139`	`139`	`GetCDLGPUShaderProgram(shaderCreator, data);`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ class ExponentOp : public Op`
`150`	`150`
`151`	`151`	`ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;`
`152`	`152`
`153`		`- void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;`
	`153`	`+ void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const override;`
`154`	`154`
`155`	`155`	`protected:`
`156`	`156`	`ConstExponentOpDataRcPtr expData() const { return DynamicPtrCast<const ExponentOpData>(data()); }`
`@@ -251,7 +251,7 @@ ConstOpCPURcPtr ExponentOp::getCPUOp(bool /fastLogExpPow/) const`
`251`	`251`	`return std::make_shared<ExponentOpCPU>(expData());`
`252`	`252`	`}`
`253`	`253`
`254`		`-void ExponentOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const`
	`254`	`+void ExponentOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const`
`255`	`255`	`{`
`256`	`256`	`GpuShaderText ss(shaderCreator->getLanguage());`
`257`	`257`	`ss.indent();`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ class ExposureContrastOp : public Op`
`49`	`49`
`50`	`50`	`ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;`
`51`	`51`
`52`		`- void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;`
	`52`	`+ void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const override;`
`53`	`53`
`54`	`54`	`protected:`
`55`	`55`	`ConstExposureContrastOpDataRcPtr ecData() const`
`@@ -135,7 +135,7 @@ ConstOpCPURcPtr ExposureContrastOp::getCPUOp(bool /fastLogExpPow/) const`
`135`	`135`	`return GetExposureContrastCPURenderer(ecOpData);`
`136`	`136`	`}`
`137`	`137`
`138`		`-void ExposureContrastOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const`
	`138`	`+void ExposureContrastOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const`
`139`	`139`	`{`
`140`	`140`	`ConstExposureContrastOpDataRcPtr ecOpData = ecData();`
`141`	`141`	`GetExposureContrastGPUShaderProgram(shaderCreator, ecOpData);`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ class FixedFunctionOp : public Op`
`45`	`45`
`46`	`46`	`ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;`
`47`	`47`
`48`		`- void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;`
	`48`	`+ void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const override;`
`49`	`49`
`50`	`50`	`protected:`
`51`	`51`	`ConstFixedFunctionOpDataRcPtr fnData() const { return DynamicPtrCast<const FixedFunctionOpData>(data()); }`
`@@ -125,7 +125,7 @@ ConstOpCPURcPtr FixedFunctionOp::getCPUOp(bool /fastLogExpPow/) const`
`125`	`125`	`return GetFixedFunctionCPURenderer(data);`
`126`	`126`	`}`
`127`	`127`
`128`		`-void FixedFunctionOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const`
	`128`	`+void FixedFunctionOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const`
`129`	`129`	`{`
`130`	`130`	`ConstFixedFunctionOpDataRcPtr fnOpData = fnData();`
`131`	`131`	`GetFixedFunctionGPUShaderProgram(shaderCreator, fnOpData);`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ class GammaOp : public Op`
`44`	`44`
`45`	`45`	`ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;`
`46`	`46`
`47`		`- void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;`
	`47`	`+ void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const override;`
`48`	`48`
`49`	`49`	`protected:`
`50`	`50`	`ConstGammaOpDataRcPtr gammaData() const { return DynamicPtrCast<const GammaOpData>(data()); }`
`@@ -123,7 +123,7 @@ ConstOpCPURcPtr GammaOp::getCPUOp(bool fastLogExpPow) const`
`123`	`123`	`return GetGammaRenderer(data, fastLogExpPow);`
`124`	`124`	`}`
`125`	`125`
`126`		`-void GammaOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const`
	`126`	`+void GammaOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const`
`127`	`127`	`{`
`128`	`128`	`ConstGammaOpDataRcPtr data = gammaData();`
`129`	`129`	`GetGammaGPUShaderProgram(shaderCreator, data);`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ class GradingPrimaryOp : public Op`
`52`	`52`
`53`	`53`	`ConstOpCPURcPtr getCPUOp(bool fastLogExpPow) const override;`
`54`	`54`
`55`		`- void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const override;`
	`55`	`+ void extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const override;`
`56`	`56`
`57`	`57`	`protected:`
`58`	`58`	`ConstGradingPrimaryOpDataRcPtr primaryData() const`
`@@ -190,7 +190,7 @@ ConstOpCPURcPtr GradingPrimaryOp::getCPUOp(bool /fastLogExpPow/) const`
`190`	`190`	`return GetGradingPrimaryCPURenderer(data);`
`191`	`191`	`}`
`192`	`192`
`193`		`-void GradingPrimaryOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator) const`
	`193`	`+void GradingPrimaryOp::extractGpuShaderInfo(GpuShaderCreatorRcPtr & shaderCreator, OptimizationFlags /oFlags/) const`
`194`	`194`	`{`
`195`	`195`	`ConstGradingPrimaryOpDataRcPtr data = primaryData();`
`196`	`196`	`GetGradingPrimaryGPUShaderProgram(shaderCreator, data);`