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 <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;

    /// Enable slapcomp with the given node.
    virtual void        enable(int target_node_id, const OP_Context&) = 0;
    void                enable(OP_Node *const node, const OP_Context &ctx)
                        { enable(node ? node->getUniqueId() : -1, ctx); }
    /// Disable slapcomp.
    virtual void        disable() = 0;
    /// Returns the on-off state of slapcomp.
    virtual bool        isEnabled() const = 0;
    /// Returns true if the last run of slapcomp had errors.
    virtual bool        hasErrors() const = 0;
    /// Returns the id of the node slapcomp was built from.
    virtual int         getTargetNode() 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;
};

/// 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                    enable(int target_node_id,
                                   const OP_Context&) override;
    /// Disable the slapcomp program.
    void                    disable() override;
    /// Returns true if slapcomp is enabled.
    bool                    isEnabled() const override { return myEnabled; }
    /// Returns true if the last run of slapcomp had errors.
    bool                    hasErrors() const override { return myHasErrors; }

    int                     getTargetNode() 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() 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();

    /// 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;
    /// Incremented each time the program is sucessfully rebuilt.
    int                             myVersion;
    /// Enable state of slapcomp.
    bool                            myEnabled;
    /// 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;
};