COP_SlapCompProgramManager.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 */

#pragma once

#include "COP_API.h"
#include "COP_ApexProgram.h"
#include "COP_CableStructure.h"
#include "COP_SlapCompInputFetcher.h"

#include <UT/UT_Span.h>
#include <OP/OP_Node.h>

/// Abstract interface for managing slapcomp.
class COP_API COP_SlapCompManager
{
    // Virtual interface that needs to be implemented by concrete subclasses...
public:
    COP_SlapCompManager() = default;
    COP_SlapCompManager(const COP_SlapCompManager&) = delete;
    COP_SlapCompManager(COP_SlapCompManager&&)      = default;
    COP_SlapCompManager    &operator=(const COP_SlapCompManager&) = delete;
    COP_SlapCompManager    &operator=(COP_SlapCompManager&&)      = default;
    virtual                ~COP_SlapCompManager()                 = default;

    /// Set the image filters defined on the USD Stage
    virtual void        setStage(const UT_Span<const int> &target_nodes,
                            const OP_Context&) = 0;

    /// Set the image filter from the viewport control (which gets applied
    /// after the stage filters)
    virtual void        setViewport(const OP_Node *node,
                            const OP_Context &ctx) = 0;

    /// Clear all filters
    void                clearAllFilters()
    {
        OP_Context ctx(0);
        setStage(UT_Span<const int>(), ctx);
        setViewport(nullptr, ctx);
    }

    /// Enable all/any slapcomp.  This sets the state (whether there are
    /// actually filters to be run or not).
    void                enable()
                        {
                            myEnableState = true;
                            updateEnableState();
                        }
    /// Disable all slapcomp.
    void                disable()
                        {
                            myEnableState = false;
                            updateEnableState();
                        }
    void                setEnabled(bool state)
                        {
                            if (state)
                                enable();
                            else
                                disable();
                        }

    /// Called when slapcomp is enabled disabled
    virtual void        updateEnableState() = 0;

    /// Returns the on-off state of slapcomp.
    bool        isEnabled() const
    {
        return getEnableState() && (hasStageFilters() || hasViewportFilters());
    }
    /// Returns the enable state
    bool                getEnableState() const { return myEnableState; }
    /// Returns whether the viewport slapcomp is enabled
    virtual bool        hasStageFilters() const = 0;
    /// Returns whether the viewport slapcomp is enabled
    virtual bool        hasViewportFilters() const = 0;
    /// Returns true if the last run of slapcomp had errors.
    virtual bool        hasErrors() const = 0;
    /// Return target nodes the slapcomp programs this was built for
    /// (typically size==1, but may be mode if there are chained programs).
    virtual UT_Array<int>       getStageTargetNodes() const = 0;
    /// Return the viewport target node
    virtual int                 getViewportTargetNode() const = 0;

    /// Sets a callback that gets called when reporting slapcomp errors.
    virtual void        setErrorCallback(void (*cb)(void*, const char*),
                                         void *data) = 0;
    /// Sets a callback that gets called when reporting slapcomp warnings.
    virtual void        setWarningCallback(void (*cb)(void*, const char*),
                                           void *data) = 0;
    /// Sets a callback that gets called when slapcomp is run.
    virtual void        setRunCallback(void (*cb)(void*), void *data) = 0;
    /// Sets a callback that gets called when slapcomp changes.
    virtual void        setUpdateCallback(void (*cb)(void*), void *data) = 0;

    /// Returns true if the slapcomp program ouputs an AOV with the given name.
    /// Should accept "color" as an alias for the "C" AOV.
    virtual bool        isSlapCompAOV(const UT_StringHolder& name) const = 0;
    /// Should return true if this slapcomp requires the input layers to bring
    /// in their cameras.
    virtual bool        expectsLayerCameras() const { return false; }

    /// Optionally builds and then runs slapcomp with the specified inputs and
    /// context. Returns successfulness.
    bool                runSlapComp(COP_SlapCompInputFetcher& input_fetcher,
                                    const OP_Context& context,
                                    bool should_build=true)
    {
        if (should_build && !build(input_fetcher, context))
            return false;
        runSlapCompImpl(input_fetcher, context);
        return true;
    }

    /// Prepares for applying slapcomp for the provided set of inputs.
    bool                build(const COP_SlapCompInputFetcher& input_fetcher,
                              const OP_Context& context)
    {
        return buildForInputs(input_fetcher.getLayerStructure(), context);
    }
    /// Prepares for applying slapcomp for inputs of the given types.
    virtual bool        buildForInputs(const COP_CableStructure& inputs,
                                       const OP_Context& context) = 0;

    /// Should run slapcomp with the specified inputs and context.
    virtual void        runSlapCompImpl(COP_SlapCompInputFetcher& input_fetcher,
                                        const OP_Context& context) = 0;

    /// Should return the outputs that this slapcomp produces.
    virtual COP_CableStructure
                        getOutputStructure() const = 0;

    /// Returns a particular output by name.
    virtual IMX_LayerPtr getOutputLayer(const UT_StringHolder& name) const = 0;

    /// Returns a version number, which is incremented every time the program is
    /// rebuilt.
    virtual int         getVersion() const = 0;
    /// Returns true if the last attempted application of slapcomp may have
    /// changed the possible outputs. This flag is is reset before each
    /// application of slapcomp.
    virtual bool        hasStateChanged() const = 0;

protected:
    /// Reports an error (through the callback if possible).
    virtual void        reportError(const char *message) = 0;
    /// Reports a warning (through the callback if possible).
    virtual void        reportWarning(const char *message) = 0;

public:
    struct Callbacks
    {
        /// Callback function to report errors to the outside world.
        void          (*myErrorCB)(void*, const char*) = nullptr;
        /// Data to send to the error reporting callback.
        void           *myErrorCBData = nullptr;
        /// Callback function to report warnings to the outside world.
        void          (*myWarningCB)(void*, const char*) = nullptr;
        /// Data to send to the warning reporting callback.
        void           *myWarningCBData = nullptr;
        /// Callback function for when the slapcomp program is run.
        void          (*myRunCB)(void*) = nullptr;
        /// Data to send to the run callback.
        void           *myRunCBData = nullptr;
        /// Callback function for when the slapcomp program is updated.
        void          (*myUpdateCB)(void*) = nullptr;
        /// Data to send to the update callback.
        void           *myUpdateCBData = nullptr;
    };
    struct Output
    {
        IMX_LayerConstPtr       myLayer;
        COP_Type                myType;
    };
    
    /// Returns an output map constructed from the outputs of the last execution
    /// of the slapcomp program. This map is safe to use even after the program
    /// outputs change as a result of building or running it. If the program is
    /// not enabled or in an error state, the returned map will be empty.
    UT_StringMap<Output>
                        getOutputs() const;

    /// Set all callbacks using a struct.
    void                setCallbacks(const Callbacks &cbs)
    {
        setErrorCallback(cbs.myErrorCB, cbs.myErrorCBData);
        setWarningCallback(cbs.myWarningCB, cbs.myWarningCBData);
        setRunCallback(cbs.myRunCB, cbs.myRunCBData);
        setUpdateCallback(cbs.myUpdateCB, cbs.myUpdateCBData);
    }

protected:
    /// Relays all warnings and messages from the error manager.
    void                reportAllErrorManagerErrors(const UT_ErrorManager&);

public:
    /// This should really be private, but due to difficult visibility rules, we
    /// just settle for this...
    /// This should only be called by higher-level managers that interface with
    /// other managers.
    virtual void        setVersion(int version) = 0;

private:
    bool                myEnableState = true;
};

/// Manages building and running a slapcomp program from a block, including
/// handling of errors.
class COP_API COP_SlapCompProgramManager : public COP_SlapCompManager
{
public:
    using Callbacks = COP_SlapCompManager::Callbacks;

    COP_SlapCompProgramManager();
    COP_SlapCompProgramManager(const COP_SlapCompProgramManager&) = delete;
    COP_SlapCompProgramManager(COP_SlapCompProgramManager&&);
    COP_SlapCompProgramManager& operator=(const COP_SlapCompProgramManager&) =
        delete;
    COP_SlapCompProgramManager& operator=(COP_SlapCompProgramManager&&);

    /// Enable and set up the slapcomp program.
    void                    setStage(const UT_Span<const int> &target_node_id,
                                   const OP_Context&) override;
    /// Enable and set up the slapcomp program for the viewportj
    void                    setViewport(const OP_Node *node,
                                   const OP_Context &ctx) override;
    void                    updateEnableState() override;
    bool                    hasStageFilters() const override;
    bool                    hasViewportFilters() const override;
    /// Returns true if the last run of slapcomp had errors.
    bool                    hasErrors() const override { return myHasErrors; }

    UT_Array<int>       getStageTargetNodes() const override;
    int                 getViewportTargetNode() const override;

    /// Rebuilds the slapcomp program if necessary. Any errors or warnings are
    /// reported through the callbacks.
    /// @see setErrorCallback
    /// @see setWarningCallback
    bool                            buildForInputs(const COP_CableStructure&,
                                                   const OP_Context&) override;

    /// Run the slapcomp program using the latest build. It is likely you want
    /// to rebuild the program prior to running it. Any errors or warnings are
    /// reported through the callbacks.
    /// @see buildProgram
    /// @see setErrorCallback
    /// @see setWarningCallback
    void                            runSlapCompImpl(COP_SlapCompInputFetcher&,
                                                    const OP_Context&) override;

    /// Returns the specified slapcomp output.
    IMX_LayerPtr        getOutputLayer(const UT_StringHolder& name) const override;

    /// Returns true if the slapcomp program ouputs an AOV with the given name.
    /// Accepts "color" as an alias for the "C" AOV.
    bool                            isSlapCompAOV(
                                            const UT_StringHolder &name)
        const override;
    bool                            expectsLayerCameras() const override;
    COP_CableStructure              getOutputStructure() const override;

    /// Get the managed slapcomp program.
    const COP_ApexProgram       &getProgram(exint i=0) const { return *myProgram; }

    /// If this returns true, then the last attempted application of slapcomp
    /// may have changed the possible outputs.
    /// This flag is reset before each application of slapcomp.
    bool                            hasStateChanged() const override
                                    { return myStateChanged; }

    /// SlapComp program version number that is incremented each time the
    /// program is sucessfully rebuilt.
    int                             getVersion() const override
                                    { return myVersion; }

    /// Sets a callback that gets called when reporting errors.
    void    setErrorCallback(void (*cb)(void*, const char*),
                             void *data) override
            {
                myCallbacks.myErrorCB = cb;
                myCallbacks.myErrorCBData = data;
            }
    /// Sets a callback that gets called when reporting warnings.
    void    setWarningCallback(void (*cb)(void*, const char*), 
                               void *data) override
            {
                myCallbacks.myWarningCB = cb;
                myCallbacks.myWarningCBData = data;
            }
    /// Sets a callback that gets called when the slapcomp program is run.
    void    setRunCallback(void (*cb)(void*), void *data) override
            {
                myCallbacks.myRunCB = cb;
                myCallbacks.myRunCBData = data;
            }
    /// Sets a callback that gets called when the slapcomp program is updated.
    void    setUpdateCallback(void (*cb)(void*), void *data) override
            {
                myCallbacks.myUpdateCB = cb;
                myCallbacks.myUpdateCBData = data;
            }

// semi-public:
    /// Called by the slapcomp program callback when it is updated.
    void                            update(const OP_Context&);

    void                            setVersion(int version) override
                                    { myVersion = version; }

protected:
    void                            reportError(const char *message) override;
    void                            reportWarning(const char *message) override;

private:
    /// Resets the state and error flags.
    void                            clearFlags();

    /// Run a single program
    bool        runSingleProgram(COP_ApexProgram *pgm,
                        COP_SlapCompInputFetcher &input_fetcher,
                        const OP_Context &context,
                        UT_Optional<UT_Vector2I> &input_wh);

    /// Reports an error if an output layer does not match the input size.
    /// This is to ensure that all AOVs have the same size.
    void                            reportOutputSizeErrors(
                                            UT_Vector2I input_size);

    /// The slapcomp program.
    UT_UniquePtr<COP_ApexProgram>   myProgram;
    UT_UniquePtr<COP_ApexProgram>   myViewportProgram;

    /// Incremented each time the program is sucessfully rebuilt.
    int                             myVersion;
    /// Enable state of slapcomp.
    bool                            myStageSet;
    bool                            myViewportSet;
    /// If this flag is true, last application of slapcomp incurred a rebuild of
    /// the program that may have changed the available output layers.
    bool                            myStateChanged;
    /// If this flag is true, last application of slapcomp had errors and
    /// failed.
    bool                            myHasErrors;

    Callbacks                       myCallbacks;
};