MOT_CloneSyncFilter.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_CloneSyncFilter.h
 *
 * COMMENTS:
 *
 */

#ifndef __MOT_CLONESYNCFILTER_H__
#define __MOT_CLONESYNCFILTER_H__

#include "MOT_API.h"
#include <UT/UT_OptionEntry.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_Vector.h>
#include <utility>

class MOT_API MOT_CloneSyncFilter
{
public:
                                 MOT_CloneSyncFilter();
                                ~MOT_CloneSyncFilter();

    const UT_StringHolder       &lopNodePath() const
                                 { return myLopNodePath; }
    void                         setLopNodePath(
                                        const UT_StringHolder &lopnodepath)
                                 { myLopNodePath = lopnodepath; }

    const UT_StringHolder       &cameraPath() const
                                 { return myCameraPath; }
    void                         setCameraPath(
                                        const UT_StringHolder &camerapath)
                                 { myCameraPath = camerapath; }

    const UT_StringHolder       &renderer() const
                                 { return myRenderer; }
    void                         setRenderer(
                                        const UT_StringHolder &renderer)
                                 { myRenderer = renderer; }

    const UT_StringHolder       &renderSettings() const
                                 { return myRenderSettings; }
    void                         setRenderSettings(
                                        const UT_StringHolder &rendersettings)
                                 { myRenderSettings = rendersettings; }

    const UT_StringHolder       &renderPass() const
                                 { return myRenderPass; }
    void                         setRenderPass(
                                        const UT_StringHolder &renderpass)
                                 { myRenderPass = renderpass; }

    std::pair<int, int>          resolution() const
                                 { return myResolution; }
    void                         setResolution(
                                        const std::pair<int, int> &resolution)
                                 { myResolution = resolution; }

    fpreal                       resScale() const
                                 { return myResScale; }
    void                         setResScale(fpreal resscale)
                                 { myResScale = resscale; }

    const UT_Vector4F           &renderRegion() const
                                 { return myRenderRegion; }
    void                         setRenderRegion(const UT_Vector4F &render_region)
                                 { myRenderRegion = render_region; }
  
    const UT_StringHolder       &displayAov() const
                                 { return myDisplayAov; }
    void                         setDisplayAov(const UT_StringHolder &aov)
                                 { myDisplayAov = aov; }

    const UT_StringArray        &availableAovs() const
                                 { return myAvailableAovs; }
    void                         setAvailableAovs(const UT_StringArray &aovs)
                                 { myAvailableAovs = aovs; }

    const UT_StringHolder       &frameExpression() const
                                 { return myFrameExpression; }
    void                         setFrameExpression(const UT_StringHolder &expr)
                                 { myFrameExpression = expr; }

    bool                         hasContextOptionExpression(
                                     const UT_StringHolder &opt) const;
    const UT_StringHolder       &contextOptionExpression(
                                        const UT_StringHolder &opt) const;
    void                         clearContextOptionExpression(
                                        const UT_StringHolder &opt);
    void                         setContextOptionExpression(
                                        const UT_StringHolder &opt,
                                        const UT_StringHolder &expr);
    const UT_StringMap<UT_StringHolder> &contextOptionExpressions() const;

    fpreal                       getFilteredFrame(fpreal frame) const;
    bool                         getFilteredContextOption(
                                        const UT_StringHolder &opt,
                                        UT_OptionEntryPtr &value) const;

private:
    UT_StringHolder                  myLopNodePath;
    UT_StringHolder                  myCameraPath;
    UT_StringHolder                  myRenderer;
    UT_StringHolder                  myRenderSettings;
    UT_StringHolder                  myRenderPass;
    fpreal                           myResScale;
    std::pair<int, int>              myResolution;
    UT_Vector4F                      myRenderRegion;
    UT_StringHolder                  myDisplayAov;
    UT_StringHolder                  myFrameExpression;
    UT_StringMap<UT_StringHolder>    myContextOptionExpressions;
    UT_StringArray                   myAvailableAovs;
};

#endif // __MOT_CLONESYNCFILTER_H__