OP/OP_Options.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.
 *
 * Produced by:
 *      Edward Lam
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OP_Options.h (C++, Utility Library)
 *
 * COMMENTS:    Subclass of UT_Options to provide some special functionality
 *              used by the SIM library.
 *
 */

#ifndef _OP_OPTIONS_H_
#define _OP_OPTIONS_H_

#include "OP_API.h"
#include <UT/UT_DMatrix4.h>
#include <UT/UT_Options.h>

class OP_Node;
class PRM_Template;

/// This class stores a set of name/value pairs. Each value can be one of
/// several different data types. No automatic conversion between data types
/// is provided, so accessing existing data requires knowledge of both the
/// data name and the data type.
class OP_API OP_Options : public UT_Options
{
public:
    explicit             OP_Options();
    virtual             ~OP_Options();

    /// Set the data in this OP_Options to be an interpolation of the data
    /// in two other OP_Options. The actual interpolation of each piece of
    /// data is performed by the OP_OptionInterpolator, which allows
    /// the interpolation behavior to be customized.
    void                 interpolate(const OP_Options &source1,
                                     const OP_Options &source2,
                                     fpreal interp);


    /// Utility function for setting an option based on a parm template.
    /// This is useful for gathering information from operator parameters
    /// to be passed on to OP_Data::setParameters().
    void                 setOptionFromTemplate(OP_Node *node,
                                               const PRM_Template &tplate,
                                               int pi, fpreal time);

    /// Utility function for setting options based on channel names of a
    /// parameter.  This splits up a single parameter tuple into multiple
    /// scalar options.
    void                setOptionFromParm(OP_Node *node, int pi, int vi,
                                                fpreal time);

    /// Utility function for setting an options based on the default value
    /// stored in a parm template. This is used to gather default values
    /// for initializing a OP_Data type. The parameter defaults are
    /// gethered into a OP_Options data structure which is passed to
    /// OP_Data::setParameters().
    void                 setOptionFromTemplateDefault(const PRM_Template &tp);

    /// Sets an option based on strings coming from a command. This is
    /// used by the dopsolvesetoption command. This funtion returns true
    /// if the parameters make sense together and result in setting an
    /// option. Otherwise false is returned.
    bool                 setOptionFromCommand(const char *optionname,
                                              const char *optionvalue,
                                              fpreal optionvaluefloat,
                                              UT_OptionType optiontype);

    /// Calculates a transform matrix based on standard transform options
    /// like t, r, s, etc.
    UT_DMatrix4          getTransformFromOptions() const;

    /// Set one OP_Options equal to another.
    const OP_Options    &operator=(const UT_Options &src);

protected:
    /// This function is called whenever data is added, removed, or changed.
    /// If the name parameter is null, then multiple pieces of data were
    /// changed simultaneously (probably through a load or assignment
    /// operation). This function just calls OP_OptionsUser::optionChanged()
    /// on each user of this data.
    virtual void         optionChanged(const char *name);

    /// These functions perform the actual interpolation of each data type.
    virtual void         getInterpolatedInt(int &value,
                                const char *name,
                                int source1,
                                int source2,
                                fpreal interp) const;
    virtual void         getInterpolatedBool(bool &value,
                                const char *name,
                                bool source1,
                                bool source2,
                                fpreal interp) const;
    virtual void         getInterpolatedFpreal(fpreal &value,
                                const char *name,
                                fpreal source1,
                                fpreal source2,
                                fpreal interp) const;
    virtual void         getInterpolatedString(UT_String &value,
                                const char *name,
                                const UT_String &source1,
                                const UT_String &source2,
                                fpreal interp) const;
    virtual void         getInterpolatedVector2(UT_Vector2 &value,
                                const char *name,
                                const UT_Vector2 &source1,
                                const UT_Vector2 &source2,
                                fpreal interp) const;
    virtual void         getInterpolatedVector3(UT_Vector3 &value,
                                const char *name,
                                const UT_Vector3 &source1,
                                const UT_Vector3 &source2,
                                fpreal interp) const;
    virtual void         getInterpolatedVector4(UT_Vector4 &value,
                                const char *name,
                                const UT_Vector4 &source1,
                                const UT_Vector4 &source2,
                                fpreal interp) const;
    virtual void         getInterpolatedQuaternion(UT_Quaternion &value,
                                const char *name,
                                const UT_Quaternion &source1,
                                const UT_Quaternion &source2,
                                fpreal interp) const;
    virtual void         getInterpolatedMatrix3(UT_Matrix3 &value,
                                const char *name,
                                const UT_Matrix3 &source1,
                                const UT_Matrix3 &source2,
                                fpreal interp) const;
    virtual void         getInterpolatedMatrix4(UT_Matrix4 &value,
                                const char *name,
                                const UT_Matrix4 &source1,
                                const UT_Matrix4 &source2,
                                fpreal interp) const;

private:
    explicit             OP_Options(const OP_Options &src);
};

#endif

---