COP_SlapCompDispatcher.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_SlapCompProgramManager.h"

/// This class is a polymorphic slapcomp manager that can be used to interface
/// with different types of slapcomps. To this end, a factory must be registered
/// with the static installFactory() method, with a checker and an allocator.
/// When a manager gets enabled with a specific node, the first factory (i.e.
/// one registered earliest) whose check the node passes will be used to run it.
class COP_API COP_SlapCompDispatcher : public COP_SlapCompManager
{
public:
    using Callbacks = COP_SlapCompManager::Callbacks;

    /// Should return true for nodes that are supported by the slapcomp type.
    using CheckFunction = bool (*)(const OP_Node*);
    /// Should dynamically allocate a new slapcomp manager for the slapcomp
    /// type.
    using AllocationFunction = COP_SlapCompManager* (*)();
    /// Call this function to register a slapcomp factory.
    /// The checker function should return true for a node if that slapcomp
    /// manager should be used for it.
    static void installFactory(CheckFunction checker,
                               AllocationFunction allocator);

private:
    /// List of available options for slapcomp.
    struct Factory
    {
        CheckFunction           myCheck;
        AllocationFunction      myAlloc;
    };
    static UT_Array<Factory>            theFactories;

    /// Given a node, returns index of the factory that is appropriate for it.
    /// Will return -1
    static int getFactoryIndex(int target_node_id);

public:
    COP_SlapCompDispatcher() {}
    COP_SlapCompDispatcher(const COP_SlapCompDispatcher&) = delete;
    COP_SlapCompDispatcher(COP_SlapCompDispatcher&&);
    COP_SlapCompDispatcher& operator=(const COP_SlapCompDispatcher&) = delete;
    COP_SlapCompDispatcher& operator=(COP_SlapCompDispatcher&&);

    /// Makes this object a copy of other, including the enable state.
    void copyFrom(const COP_SlapCompDispatcher& other,
                  const OP_Context& context);

    void setStage(const UT_Span<const int> &node_ids, const OP_Context&) override;
    void setViewport(const OP_Node *cop, const OP_Context&) override;
    bool hasStageFilters() const override;
    bool hasViewportFilters() const override;
    void updateEnableState() override;
    bool hasErrors() const override;
    UT_Array<int> getStageTargetNodes() const override;
    int           getViewportTargetNode() const override;

    void setErrorCallback(void (*cb)(void*, const char*), void* data) override;
    void setWarningCallback(void (*cb)(void*, const char*), void* data)
        override;
    void setRunCallback(void (*cb)(void*), void* data) override;
    void setUpdateCallback(void (*cb)(void*), void* data) override;

    bool isSlapCompAOV(const UT_StringHolder& name) const override;

    bool buildForInputs(const COP_CableStructure& inputs,
                        const OP_Context& context) override;
    void runSlapCompImpl(COP_SlapCompInputFetcher& input_fetcher,
                         const OP_Context& context) override;

    COP_CableStructure getOutputStructure() const override;
    IMX_LayerPtr getOutputLayer(const UT_StringHolder& name) const override;

    int getVersion() const override
    {
        if (myManager)
            return myManager->getVersion();
        return myVersion;
    }
    bool hasStateChanged() const override
    {
        if (myManager)
            return myManager->hasStateChanged();
        return false;
    }

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

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

    void        clearManager();         // Clear the list manager

protected:
    Callbacks                           myCallbacks;
    UT_UniquePtr<COP_SlapCompManager>   myManager;
    int                                 myCurrentType = -1;

    // TODO: The way things are organized does not make much sense. The
    // dispatcher and the actual manager each have a version and they can become
    // out of sync. To fix #151473, for now, these are used when `myManager`
    // does not exist to ensure that the version stays unique for each build.
    // Ideally this state should only exist in one place.
    int                                 myVersion = 0;
};