Enable to draw the curve eval only for a specific hue curve. (#11)

(cherry picked from commit d658e70)
Signed-off-by: Doug Walker <[email protected]>

Author: larochj

include/OpenColorIO/OpenColorTransforms.h

@@ -1308,6 +1308,18 @@ class OCIOEXPORT GradingHueCurveTransform : public Transform
     virtual bool getBypassLinToLog() const = 0;
     virtual void setBypassLinToLog(bool bypass) = 0;
 
+    /**
+     * Enable drawCurveOnly mode to return the output value of a spline curve without any of the 
+     * other associated processing of the RGB values. This is useful when the curves need to be 
+     * graphed independently in a user interface. To use this, set the curve parameters on the 
+     * Hue-Sat curve. The R, G, and B values will be sent through that curve but with the interpretation 
+     * that they are the input axis to the curve (which would be hue, sat, or luma) rather than RGB.
+     * This mode ignores the setting of BypassLinToLog, so for scene-linear curves the luma values are 
+     * interpreted as already being in the logarithmic (f-stop) space.
+     */
+    virtual bool getDrawCurveOnly() const = 0;
+    virtual void setDrawCurveOnly( bool drawCurveOnly ) = 0;
+
     ///**
     // * Parameters can be made dynamic so the values can be changed through the CPU or GPU processor,
     // * but if there are several GradingHueCurveTransform only one can have dynamic parameters.

src/OpenColorIO/ops/gradinghuecurve/GradingHueCurveOpData.cpp

@@ -68,6 +68,7 @@ GradingHueCurveOpData & GradingHueCurveOpData::operator=(const GradingHueCurveOp
     m_direction = rhs.m_direction;
     m_style = rhs.m_style;
     m_bypassLinToLog = rhs.m_bypassLinToLog;
+    m_drawCurveOnly = rhs.m_drawCurveOnly;
 
     // Copy dynamic properties. Sharing happens when needed, with CPUOp for instance.
     m_value->setValue(rhs.m_value->getValue());
@@ -76,6 +77,7 @@ GradingHueCurveOpData & GradingHueCurveOpData::operator=(const GradingHueCurveOp
         m_value->makeDynamic();
     }
 
+
     return *this;
 }
 
@@ -228,6 +230,7 @@ bool GradingHueCurveOpData::equals(const OpData & other) const
     if (m_direction      != rop->m_direction ||
         m_style          != rop->m_style ||
         m_bypassLinToLog != rop->m_bypassLinToLog ||
+        m_drawCurveOnly  != rop->m_drawCurveOnly ||
        !m_value->equals(  *(rop->m_value)  ))
     {
         return false;

src/OpenColorIO/ops/gradinghuecurve/GradingHueCurveOpData.h

@@ -66,6 +66,9 @@ class GradingHueCurveOpData : public OpData
     bool getBypassLinToLog() const noexcept { return m_bypassLinToLog; }
     void setBypassLinToLog(bool bypass) noexcept { m_bypassLinToLog = bypass; }
 
+    bool getDrawCurveOnly() const noexcept { return m_drawCurveOnly; }
+    void setDrawCurveOnly(bool drawCurveOnly) noexcept { m_drawCurveOnly = drawCurveOnly; }
+
     TransformDirection getDirection() const noexcept;
     void setDirection(TransformDirection dir) noexcept;
 
@@ -85,6 +88,7 @@ class GradingHueCurveOpData : public OpData
     GradingStyle                            m_style;
     DynamicPropertyGradingHueCurveImplRcPtr m_value;
     bool                                    m_bypassLinToLog{ false };
+    bool                                    m_drawCurveOnly{ false };
     TransformDirection                      m_direction{ TRANSFORM_DIR_FORWARD };
 };
 

src/OpenColorIO/ops/gradinghuecurve/GradingHueCurveOpGPU.cpp

@@ -256,8 +256,18 @@ void AddGCForwardShader(GpuShaderCreatorRcPtr & shaderCreator,
                         const GCProperties & props,
                         bool dyn,
                         bool doLinToLog,
+                        bool drawCurveOnly,
                         GradingStyle style)
 {
+    const std::string pix(shaderCreator->getPixelName());
+    if(drawCurveOnly)
+    {
+        st.newLine() << pix << ".r = " << props.m_eval << "(1, " << pix << ".r, 1.);"; // HUE-SAT
+        st.newLine() << pix << ".g = " << props.m_eval << "(1, " << pix << ".g, 1.);"; // HUE-SAT
+        st.newLine() << pix << ".b = " << props.m_eval << "(1, " << pix << ".b, 1.);"; // HUE-SAT
+        return;
+    }
+
     if (dyn)
     {
         st.newLine() << "if (!" << props.m_localBypass << ")";
@@ -299,8 +309,6 @@ void AddGCForwardShader(GpuShaderCreatorRcPtr & shaderCreator,
         st.newLine() << "";
     }
 
-    const std::string pix(shaderCreator->getPixelName());
-
     st.newLine() << "";
     st.newLine() << "float hueSatGain = max(0., " << props.m_eval << "(1, " << pix << ".r, 1.));"; // HUE-SAT
     st.newLine() << "float hueLumGain = max(0., " << props.m_eval << "(2, " << pix << ".r, 1.));"; // HUE-LUM
@@ -463,25 +471,25 @@ void GetHueCurveGPUShaderProgram(GpuShaderCreatorRcPtr & shaderCreator,
         shaderCreator->addDynamicProperty(newProp);
 
         // Add uniforms only if needed.
-        AddGCPropertiesUniforms(shaderCreator, shaderProp, properties); // _addAttributeTextToShaderProgram
+        AddGCPropertiesUniforms(shaderCreator, shaderProp, properties);
 
         // Add helper function plus global variables if they are not dynamic.
-        AddCurveEvalMethodTextToShaderProgram(shaderCreator, gcData, properties, dyn); // _addHelperMethodTextToShaderProgram
+        AddCurveEvalMethodTextToShaderProgram(shaderCreator, gcData, properties, dyn);
     }
     else
     {
         // Declare the op specific helper function.
         AddCurveEvalMethodTextToShaderProgram(shaderCreator, gcData, properties, dyn);
     }
 
-    const bool bypassLinToLog = (style == GRADING_LIN) && !gcData->getBypassLinToLog();
+    const bool doLinToLog = (style == GRADING_LIN) && !gcData->getBypassLinToLog();
     switch (dir)
     {
     case TRANSFORM_DIR_FORWARD:
-        AddGCForwardShader(shaderCreator, st, properties, dyn, bypassLinToLog, style); // _addProcessingTextToShaderProgram
+        AddGCForwardShader(shaderCreator, st, properties, dyn, doLinToLog, gcData->getDrawCurveOnly(), style);
         break;
     case TRANSFORM_DIR_INVERSE: // TODO: Implement the inverse shader.
-        //AddGCInverseShader(shaderCreator, st, properties, dyn, bypassLinToLog, style); // _addProcessingTextToShaderProgram
+        //AddGCInverseShader(shaderCreator, st, properties, dyn, bypassLinToLog, style);
         break;
     }
 

src/OpenColorIO/transforms/GradingHueCurveTransform.cpp

@@ -121,6 +121,16 @@ void GradingHueCurveTransformImpl::setBypassLinToLog(bool bypass) noexcept
     data().setBypassLinToLog(bypass);
 }
 
+bool GradingHueCurveTransformImpl::getDrawCurveOnly() const noexcept
+{
+    return data().getDrawCurveOnly();
+}
+
+void GradingHueCurveTransformImpl::setDrawCurveOnly( bool drawCurveOnly ) noexcept
+{
+    data().setDrawCurveOnly( drawCurveOnly );
+}
+
 bool GradingHueCurveTransformImpl::isDynamic() const noexcept
 {
     return data().isDynamic();

src/OpenColorIO/transforms/GradingHueCurveTransform.h

@@ -48,6 +48,9 @@ class GradingHueCurveTransformImpl : public GradingHueCurveTransform
 
     bool getBypassLinToLog() const noexcept override;
     void setBypassLinToLog(bool bypass) noexcept override;
+    
+    bool getDrawCurveOnly() const noexcept override;
+    void setDrawCurveOnly(bool drawCurveOnly) noexcept override;
 
     bool isDynamic() const noexcept override;
     void makeDynamic() noexcept override;