MOT_CloneMessage.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.
 *
 * NAME:        MOT_CloneMessage.h
 *
 * COMMENTS:
 *
 */

#ifndef __MOT_CLONEMESSAGE_H__
#define __MOT_CLONEMESSAGE_H__

#include <OP/OP_DataTypes.h>
#include <CH/CH_ExprLanguage.h>
#include <UT/UT_Options.h>
#include <UT/UT_Rect.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_UniversalLogSource.h>
#include <UT/UT_Vector2.h>
#include <optional>

class MOT_Director;
class LOP_Node;
class PXL_Raster;

typedef int64 MOT_CloneMessageId;
#define MOT_CLONE_MESSAGE_INVALID_ID -1
#define MOT_MAX_MESSAGE_LENGTH_HEADER "SetMaxMessageLength"
#define MOT_MAX_MESSAGE_LENGTH_DEFAULT (1024 * 1024 * 64)

class MOT_CloneMessage
{
public:
                             MOT_CloneMessage();
                             MOT_CloneMessage(const UT_StringRef &msg);
    virtual                 ~MOT_CloneMessage();

    const UT_Options        &options() const
                             { return myOptions; }
    UT_Options              &options()
                             { return myOptions; }
    const UT_StringHolder   &extraData() const
                             { return myExtraData; }
    UT_StringHolder         &extraData()
                             { return myExtraData; }
    MOT_CloneMessageId       uniqueId() const
                             { return myUniqueId; }
    void                     fillWorkBuffer(UT_WorkBuffer &buf) const;

    static const UT_StringHolder &schemaKey();
    static const UT_StringHolder &uniqueIdKey();

protected:
    UT_StringHolder          myExtraData;
    UT_Options               myOptions;
    MOT_CloneMessageId       myUniqueId;
};

template<class SchemaClass>
class MOT_SchemaMessage
{
public:
                             MOT_SchemaMessage(const MOT_CloneMessage &rmsg)
                                : myMsg(rmsg)
                             { }
    virtual                 ~MOT_SchemaMessage()
                             { }

    bool                     isValid() const
                             {
                                 UT_StringHolder schema =
                                     myMsg.options().getOptionS(
                                        MOT_CloneMessage::schemaKey());
                                 return schema == SchemaClass::schemaName();
                             }

protected:
    static void              createMessage(MOT_CloneMessage &rmsg)
                             {
                                rmsg.options().setOptionS(
                                    MOT_CloneMessage::schemaKey(),
                                    SchemaClass::schemaName());
                                rmsg.options().setOptionI(
                                    MOT_CloneMessage::uniqueIdKey(),
                                    rmsg.uniqueId());
                             }

    const MOT_CloneMessage  &myMsg;
};

class MOT_ScriptMessage :
    public MOT_SchemaMessage<MOT_ScriptMessage>
{
public:
                             MOT_ScriptMessage(const MOT_CloneMessage &rmsg)
                                : MOT_SchemaMessage(rmsg)
                             { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    const UT_StringRef &script,
                                    CH_ScriptLanguage lang);

    bool                     runScript() const;
};

class MOT_RemoteExecMessage :
    public MOT_SchemaMessage<MOT_RemoteExecMessage>
{
public:
    MOT_RemoteExecMessage(const MOT_CloneMessage &rmsg)
        : MOT_SchemaMessage(rmsg)
    { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    const UT_StringHolder &functionname,
                                    const UT_Options &parameters);

    void                     execute() const;
};

class MOT_ConfigureMessage :
    public MOT_SchemaMessage<MOT_ConfigureMessage>
{
public:
                             MOT_ConfigureMessage(const MOT_CloneMessage &rmsg)
                                : MOT_SchemaMessage(rmsg)
                             { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    const UT_StringRef &lopnodepath,
                                    const UT_StringRef &cameraprimpath,
                                    const UT_StringRef &renderer,
                                    const UT_StringRef &rendersettings,
                                    const UT_StringRef &displayaov,
                                    fpreal resscale,
                                    int width,
                                    int height);

    LOP_Node                *getLopNode() const;
    UT_StringHolder          getCameraPrimPath() const;
    UT_StringHolder          getRenderer() const;
    UT_StringHolder          getRenderSettings() const;
    UT_StringHolder          getDisplayAov() const;
    fpreal                   getResScale() const;
    int                      getWidth() const;
    int                      getHeight() const;
};

class MOT_FrameMessage :
    public MOT_SchemaMessage<MOT_FrameMessage>
{
public:
                             MOT_FrameMessage(const MOT_CloneMessage &rmsg)
                                : MOT_SchemaMessage(rmsg)
                             { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    fpreal frame);

    fpreal                   getFrame() const;
};

class MOT_ProcessUpdatesMessage :
    public MOT_SchemaMessage<MOT_ProcessUpdatesMessage>
{
public:
    MOT_ProcessUpdatesMessage(const MOT_CloneMessage &rmsg)
        : MOT_SchemaMessage(rmsg)
    { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    bool process_updates);

    bool                     getProcessUpdates() const;
};

class MOT_HipFileMessage :
    public MOT_SchemaMessage<MOT_HipFileMessage>
{
public:
                             MOT_HipFileMessage(const MOT_CloneMessage &rmsg)
                                : MOT_SchemaMessage(rmsg)
                             { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg);

    bool                     setEnvVars() const;
    bool                     loadHipFile() const;
};

class MOT_SaveItemsMessage :
    public MOT_SchemaMessage<MOT_SaveItemsMessage>
{
public:
    MOT_SaveItemsMessage(const MOT_CloneMessage &rmsg)
        : MOT_SchemaMessage(rmsg)
    { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    const OP_NetworkBoxItemList &items);
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    OP_NetworkBoxItem *item);

    bool                     load() const;
};

class MOT_LogEntriesMessage :
    public MOT_SchemaMessage<MOT_LogEntriesMessage>
{
public:
    MOT_LogEntriesMessage(const MOT_CloneMessage &rmsg)
        : MOT_SchemaMessage(rmsg)
    { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    const UT_UniversalLogEntryArray &
                                        log_entries);

    bool                     loadLogEntries(UT_UniversalLogEntryArray &
                                    log_entries) const;
};

class MOT_SocketErrorMessage :
    public MOT_SchemaMessage<MOT_SocketErrorMessage>
{
public:
    MOT_SocketErrorMessage(const MOT_CloneMessage &rmsg)
        : MOT_SchemaMessage(rmsg)
    { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    const UT_StringRef &err);

    UT_StringHolder          errorMessage() const;
};

class MOT_ImageMessage :
    public MOT_SchemaMessage<MOT_ImageMessage>
{
public:
                             MOT_ImageMessage(const MOT_CloneMessage &rmsg)
                                : MOT_SchemaMessage(rmsg)
                             { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    const UT_StringMap<UT_UniquePtr<PXL_Raster>> &rasters,
                                    const UT_StringArray &availableaovs,
                                    const UT_Options &stats,
                                    const UT_Vector2i &fullres,
                                    const UT_DimRect &datawindow);

    UT_StringMap<UT_UniquePtr<PXL_Raster>>   createImages() const;
    UT_StringArray                           availableAovs() const;
    UT_Options                               stats() const;
    std::optional<UT_Vector2i>               fullRes() const;
    std::optional<UT_DimRect>                dataWindow() const;
    int                                      skippedRasters() const;
};

class MOT_AckMessage :
    public MOT_SchemaMessage<MOT_AckMessage>
{
public:
                             MOT_AckMessage(const MOT_CloneMessage &rmsg)
                                : MOT_SchemaMessage(rmsg)
                             { }

    static const UT_StringHolder &schemaName();
    static void              createMessage(MOT_CloneMessage &rmsg,
                                    MOT_CloneMessageId ackedid);

    MOT_CloneMessageId       ackedUniqueId() const;
};

#endif // __MOT_CLONEMESSAGE_H__