SG-37377: Add Compare to Live Review (#738)

### [SG-37377](https://jira.autodesk.com/browse/SG-37377): Add Compare
to Live Review

### Summarize your change.

- [X] Add Compare OTIO schema and hook
- [X] Add Opacity Compare mode in IPGraph and in OTIO compare hook
- [X] Add Wipe (angular mask) mode in IPGraph and in OTIO compare hook
- [X] Add Reverse Wipe shader to handle swapping versions
- [X] Update requirements.txt to use the main branch of the OTIO Github
repo to get the latest fixes for OTIO V2d before the next release is
available
- [X] `read_otio_string` was removed since the parsing of the OTIO
Timeline is now down directly in the Live Review plugin
- [X] Handle OTIO GeneratorReference to use clips with plain coloured
background in OTIO tests

### Describe the reason for the change.

In the web app, users can use four different compare modes when they are
analyzing two versions. Since some of those compare modes were not, or
only partially, present in RV, these PR contains all the changes
required to add them. Opacity and Compare implementations are based on
what is in
[Create](https://git.autodesk.com/media-and-entertainment/shotgun-rv/pull/193).
Note that Side by Side is entirely in the Live Review plugin in [this
PR](https://git.autodesk.com/media-and-entertainment/rv/pull/342). The
difference mode will need to be added in a following PR since some
investigations need to be done to identify why the web app and RV have
such different ways of implementing this mode.

### Describe what you have tested and on which operating system.

The changes were tested on macOS during a Live Session between RV and
the web app on
[https://sg-create-prod.shotgunstudio.com/](https://sg-create-prod.shotgunstudio.com/).

---------

Signed-off-by: Éloïse Brosseau <eloise.brosseau@autodesk.com>

Author: eloisebrosseau

.clang-tidy

@@ -14,6 +14,7 @@ Checks: >
   -modernize-use-trailing-return-type,
   performance-*,
   readability-*,
+  -readability-uppercase-literal-suffix,
 WarningsAsErrors: ''
 FormatStyle: 'file'
 ...

src/build/requirements.txt

@@ -2,7 +2,8 @@
 
 pip                     # License: MIT License (MIT)
 setuptools              # License: MIT License
-OpenTimelineIO==0.16    # License: Other/Proprietary License (Modified Apache 2.0 License)
+# We need to use the main branch of the OTIO Github repo since the latest release available as a Pypi package is missing some features we need for Live Review
+git+https://github.com/AcademySoftwareFoundation/OpenTimelineIO@main#egg=OpenTimelineIO # License: Other/Proprietary License (Modified Apache 2.0 License)
 PyOpenGL                # License: BSD License (BSD)
 # PyOpenGL_accelerate as issue with native arm64 build on MacOS.
 # Use PyOpenGL_accelerate only on x86_64 platform.

src/lib/ip/IPBaseNodes/IPBaseNodes/SequenceIPNode.h

@@ -144,7 +144,13 @@ namespace IPCore
         IntProperty* m_outputSize;
         IntProperty* m_interactiveSize;
         StringProperty* m_inputsBlendingModes;
+        FloatProperty* m_inputsOpacities;
         IntProperty* m_supportReversedOrderBlending;
+        FloatProperty* m_inputsAngularMaskPivotX;
+        FloatProperty* m_inputsAngularMaskPivotY;
+        FloatProperty* m_inputsAngularMaskAngleInRadians;
+        IntProperty* m_inputsAngularMaskActive;
+        IntProperty* m_inputsReverseAngularMask;
 
         /// this signal is called before all state change
         VoidSignal m_changingSignal;

src/lib/ip/IPBaseNodes/SequenceIPNode.cpp

@@ -13,6 +13,8 @@
 #include <IPCore/IPGraph.h>
 #include <IPCore/ShaderUtil.h>
 #include <IPCore/GroupIPNode.h>
+#include <IPCore/ShaderCommon.h>
+#include <TwkMath/Vec2.h>
 #include <TwkFB/FrameBuffer.h>
 #include <TwkFB/Operations.h>
 #include <iostream>
@@ -85,9 +87,30 @@ namespace IPCore
         // just like any other per-input EDL information.
         m_inputsBlendingModes = declareProperty<StringProperty>(
             "composite.inputBlendModes", "", 0, false);
-        // since it is per input, make sure the property contains is emptied at
-        // creation time
+
+        m_inputsOpacities = declareProperty<FloatProperty>(
+            "composite.inputOpacities", 1.0f, nullptr, false);
+
+        m_inputsAngularMaskPivotX = declareProperty<FloatProperty>(
+            "composite.inputAngularMaskPivotX", 0.0f, nullptr, false);
+        m_inputsAngularMaskPivotY = declareProperty<FloatProperty>(
+            "composite.inputAngularMaskPivotY", 0.0f, nullptr, false);
+        m_inputsAngularMaskAngleInRadians = declareProperty<FloatProperty>(
+            "composite.inputAngularMaskAngleInRadians", 0.0f, nullptr, false);
+        m_inputsAngularMaskActive =
+            declareProperty<IntProperty>("composite.inputAngularMaskActive", 1);
+        m_inputsReverseAngularMask =
+            declareProperty<IntProperty>("composite.swapAngularMaskInput", 1);
+
+        // since they are per input, make sure the property containers are
+        // emptied at creation time
         m_inputsBlendingModes->erase(0, 1);
+        m_inputsOpacities->erase(0, 1);
+        m_inputsAngularMaskPivotX->erase(0, 1);
+        m_inputsAngularMaskPivotY->erase(0, 1);
+        m_inputsAngularMaskAngleInRadians->erase(0, 1);
+        m_inputsAngularMaskActive->erase(0, 1);
+        m_inputsReverseAngularMask->erase(0, 1);
 
         // By default, the output of this node support reverse-order blending.
         // this is mainly kept for backward compatibility reason.
@@ -370,6 +393,34 @@ namespace IPCore
 
         // Shader::installAdaptiveBoxResizeRecursive(root);
 
+        // If we have per-input opacities, now is the time to use them
+        if (source >= 0 && source < m_inputsOpacities->size()
+            && child->shaderExpr != nullptr)
+        {
+            child->shaderExpr = Shader::newOpacity(
+                child, child->shaderExpr, (*m_inputsOpacities)[source]);
+        }
+
+        const bool isSourceValid =
+            source >= 0 && source < m_inputsAngularMaskPivotX->size()
+            && source < m_inputsAngularMaskPivotY->size()
+            && source < m_inputsAngularMaskAngleInRadians->size()
+            && source < m_inputsAngularMaskActive->size()
+            && source < m_inputsReverseAngularMask->size();
+
+        if (isSourceValid && ((*m_inputsAngularMaskActive)[source] != 0))
+        {
+
+            const float pivotX = (*m_inputsAngularMaskPivotX)[source];
+            const float pivotY = (*m_inputsAngularMaskPivotY)[source];
+            const float angleInRadians =
+                (*m_inputsAngularMaskAngleInRadians)[source];
+
+            child->shaderExpr = Shader::newAngularMask(
+                child, child->shaderExpr, Vec2f(pivotX, pivotY), angleInRadians,
+                (*m_inputsReverseAngularMask)[source] != 0);
+        }
+
         root->appendChild(child);
 
         if (m_clipCaching && context.thread == CacheEvalThread

src/lib/ip/IPCore/CMakeLists.txt

@@ -126,6 +126,9 @@ SET(_shaders
     StereoChecker
     StereoAnaglyph
     StereoLumAnaglyph
+    AngularMask
+    ReverseAngularMask
+    Opacity
     Over2
     Over3
     Over4
@@ -259,9 +262,7 @@ ELSEIF(RV_TARGET_DARWIN)
     PUBLIC OpenCL::OpenCL
   )
 ELSE()
-  TARGET_LINK_LIBRARIES(
-    ${_target}
-  )
+  TARGET_LINK_LIBRARIES(${_target})
 ENDIF()
 
 RV_STAGE(TYPE "LIBRARY" TARGET ${_target})

src/lib/ip/IPCore/IPCore/ShaderCommon.h

@@ -7,10 +7,10 @@
 //
 #ifndef __IPCore__ShaderCommon__h__
 #define __IPCore__ShaderCommon__h__
-#include <iostream>
 #include <IPCore/ShaderExpression.h>
 #include <IPCore/IPImage.h>
 #include <TwkMath/Mat44.h>
+#include <TwkMath/Vec2.h>
 
 namespace IPCore
 {
@@ -252,6 +252,14 @@ namespace IPCore
             const TwkMath::Vec2f& center, const TwkMath::Vec2f& f,
             const TwkMath::Vec2f& cropRatio);
 
+        Expression* newOpacity(const IPImage* image, Expression* expr,
+                               float opacity);
+
+        Expression* newAngularMask(const IPImage* image, Expression* expr,
+                                   const TwkMath::Vec2f& pivot,
+                                   float angleInRadians,
+                                   bool isReverseAngularMask);
+
         //
         //  ICC profile shaders
         //

src/lib/ip/IPCore/IPCore/ShaderFunction.h

@@ -210,6 +210,8 @@ namespace IPCore
 
             bool usesOutputST() const { return m_usesOutputST; }
 
+            bool usesFragmentPosition() const { return m_usesFragmentPosition; }
+
             void releaseCompiledState() const;
             const Symbol::Type returnType() const;
 
@@ -280,8 +282,9 @@ namespace IPCore
             std::string m_hashString;
             ResourceUsage m_resourceUsage;
             bool m_inline;
-            bool m_usesOutputSize;
-            bool m_usesOutputST;
+            bool m_usesOutputSize{false};
+            bool m_usesOutputST{false};
+            bool m_usesFragmentPosition{false};
             bool m_usesSampling;
 
             friend class Program;

src/lib/ip/IPCore/IPCore/ShaderProgram.h

@@ -188,7 +188,6 @@ namespace IPCore
             // output uniform variables needed in case of uncropped images
             void outputUncropUniforms(std::ostream&, const Expression*);
 
-        private:
             Expression* m_expr;
             GraphIDSet m_outputSTSet;
             GraphIDSet m_outputSizeSet;
@@ -203,8 +202,9 @@ namespace IPCore
             size_t m_totalST;
             Function* m_main;
             std::string m_vertexCode;
-            bool m_needOutputSize;
-            bool m_needOutputST;
+            bool m_needOutputSize{false};
+            bool m_needOutputST{false};
+            bool m_needFragmentPosition{false};
         };
 
         class ProgramCache

src/lib/ip/IPCore/IPCore/ShaderSymbol.h

@@ -145,6 +145,7 @@ namespace IPCore
                 Coord2DRectType,
                 InputImageType,
                 OutputImageType,
+                FragmentPositionType,
             };
 
             Symbol(Qualifier c, const std::string& name, Type t,
@@ -189,6 +190,11 @@ namespace IPCore
 
             bool isInputImage() const { return m_type == InputImageType; }
 
+            [[nodiscard]] bool isFragmentPositon() const
+            {
+                return m_type == FragmentPositionType;
+            }
+
             bool operator==(const Symbol& s) const
             {
                 return s.m_name == m_name && s.m_qualifier == m_qualifier

src/lib/ip/IPCore/ImageRenderer.cpp

@@ -2705,8 +2705,8 @@ namespace IPCore
             case IPImage::Dissolve:
                 glEnable(GL_BLEND);
                 glBlendEquation(GL_FUNC_ADD);
-                glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE,
-                                    GL_ONE_MINUS_SRC_ALPHA);
+                // src is assumed premultiplied
+                glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
                 break;
             case IPImage::Add:
                 glEnable(GL_BLEND);

src/lib/ip/IPCore/ShaderCommon.cpp

@@ -7,9 +7,14 @@
 //
 #include <IPCore/ShaderCommon.h>
 #include <IPCore/ShaderState.h>
+#include <IPCore/ShaderExpression.h>
+#include <IPCore/ShaderFunction.h>
+#include <IPCore/ShaderSymbol.h>
+#include <IPCore/IPImage.h>
 #include <TwkGLF/GL.h>
 #include <TwkFB/Operations.h>
 #include <TwkMath/MatrixColor.h>
+#include <TwkMath/Vec2.h>
 #include <boost/thread/mutex.hpp>
 #include <boost/functional/hash.hpp>
 
@@ -115,6 +120,9 @@ extern const char* StereoScanline_glsl;
 extern const char* StereoChecker_glsl;
 extern const char* StereoAnaglyph_glsl;
 extern const char* StereoLumAnaglyph_glsl;
+extern const char* AngularMask_glsl;
+extern const char* ReverseAngularMask_glsl;
+extern const char* Opacity_glsl;
 extern const char* Over2_glsl;
 extern const char* Over3_glsl;
 extern const char* Over4_glsl;
@@ -314,6 +322,9 @@ namespace IPCore
         static Function* Shader_StereoChecker = 0;
         static Function* Shader_StereoAnaglyph = 0;
         static Function* Shader_StereoLumAnaglyph = 0;
+        static Function* Shader_AngularMask = 0;
+        static Function* Shader_ReverseAngularMask = 0;
+        static Function* Shader_Opacity = 0;
         static Function* Shader_Over = 0;
         static Function* Shader_Add = 0;
         static Function* Shader_Difference = 0;
@@ -2587,6 +2598,40 @@ namespace IPCore
             return Shader_LensWarp3DE4AnamorphicDegree6;
         }
 
+        Function* Opacity()
+        {
+            if (Shader_Opacity == nullptr)
+            {
+                Shader_Opacity = new Shader::Function("Opacity", Opacity_glsl,
+                                                      Shader::Function::Color);
+            }
+
+            return Shader_Opacity;
+        }
+
+        Function* AngularMask()
+        {
+            if (Shader_AngularMask == nullptr)
+            {
+                Shader_AngularMask = new Shader::Function(
+                    "AngularMask", AngularMask_glsl, Shader::Function::Filter);
+            }
+
+            return Shader_AngularMask;
+        }
+
+        Function* ReverseAngularMask()
+        {
+            if (Shader_ReverseAngularMask == nullptr)
+            {
+                Shader_ReverseAngularMask = new Shader::Function(
+                    "ReverseAngularMask", ReverseAngularMask_glsl,
+                    Shader::Function::Filter);
+            }
+
+            return Shader_ReverseAngularMask;
+        }
+
         //--
 
         Expression* newDither(const IPImage* image, Expression* A,
@@ -5626,6 +5671,41 @@ namespace IPCore
             return new Expression(F, args, image);
         }
 
+        Expression* newOpacity(const IPImage* image, Expression* expr,
+                               const float opacity)
+        {
+            const Function* F = Opacity();
+            ArgumentVector args(F->parameters().size());
+            size_t i = 0;
+            args[i] = new BoundExpression(F->parameters()[i], expr);
+            i++;
+            args[i] = new BoundFloat(F->parameters()[i], opacity);
+            i++;
+
+            return new Expression(F, args, image);
+        }
+
+        Expression* newAngularMask(const IPImage* image, Expression* expr,
+                                   const TwkMath::Vec2f& pivot,
+                                   const float angleInRadians,
+                                   bool isReverseAngularMask)
+        {
+            const Function* F =
+                isReverseAngularMask ? ReverseAngularMask() : AngularMask();
+            ArgumentVector args(F->parameters().size());
+            size_t i = 0;
+            args[i] = new BoundExpression(F->parameters()[i], expr);
+            i++;
+            args[i] = new BoundVec2f(F->parameters()[i], pivot);
+            i++;
+            args[i] = new BoundFloat(F->parameters()[i], angleInRadians);
+            i++;
+            args[i] = new BoundVec2f(F->parameters()[i], Vec2f(0.0f));
+            i++;
+
+            return new Expression(F, args, image);
+        }
+
         //--
 
         Expression* sourceAssemblyShader(IPImage* image, bool bgra, bool force)