SOP_PolyWire.proto.h

Go to the documentation of this file.

/* Automagically Generated by generate_proto.py
 * Do not Edit
 */
#pragma once

#include <SOP/SOP_API.h>
#include <SOP/SOP_NodeVerb.h>
#include <SOP/SOP_GraphProxy.h>

#include <OP/OP_Utils.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_IStream.h>
#include <UT/UT_NTStreamUtil.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringStream.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_EnvControl.h>
#include <SYS/SYS_Types.h>

class DEP_MicroNode;
namespace SOP_PolyWireEnums
{
    enum class UseScaleAttrib
    {
        CONSTANT = 0,
        ATTRIB
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(UseScaleAttrib enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case UseScaleAttrib::CONSTANT: return "constant"_sh;
        case UseScaleAttrib::ATTRIB: return "attrib"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class UseSmoothAttrib
    {
        CONSTANT = 0,
        ATTRIB
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(UseSmoothAttrib enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case UseSmoothAttrib::CONSTANT: return "constant"_sh;
        case UseSmoothAttrib::ATTRIB: return "attrib"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class UseDivAttrib
    {
        CONSTANT = 0,
        ATTRIB
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(UseDivAttrib enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case UseDivAttrib::CONSTANT: return "constant"_sh;
        case UseDivAttrib::ATTRIB: return "attrib"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class UseSegsAttrib
    {
        CONSTANT = 0,
        ATTRIB
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(UseSegsAttrib enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case UseSegsAttrib::CONSTANT: return "constant"_sh;
        case UseSegsAttrib::ATTRIB: return "attrib"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class UseTextVAttrib
    {
        CONSTANT = 0,
        ATTRIB
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(UseTextVAttrib enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case UseTextVAttrib::CONSTANT: return "constant"_sh;
        case UseTextVAttrib::ATTRIB: return "attrib"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class UseUpAttrib
    {
        OFF = 0,
        ON,
        ATTRIB
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(UseUpAttrib enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case UseUpAttrib::OFF: return "off"_sh;
        case UseUpAttrib::ON: return "on"_sh;
        case UseUpAttrib::ATTRIB: return "attrib"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

}


class SOP_API SOP_PolyWireParms  : public SOP_NodeParms
{
public:
    static int version() { return 1; }

    SOP_PolyWireParms()
    {
        myGroup = ""_UTsh;
        myRadius = 0.1;
        myUseScaleAttrib = 0;
        myScaleAttrib = "pscale"_UTsh;
        myJointcorrect = true;
        myMaxscale = 2;
        mySmooth = 1;
        myUseSmoothAttrib = 0;
        mySmoothAttrib = "smooth"_UTsh;
        myMaxValence = 25;
        myDiv = 4;
        myUseDivAttrib = 0;
        myDivAttrib = "div"_UTsh;
        mySegs = 1;
        myUseSegsAttrib = 0;
        mySegsAttrib = "segs"_UTsh;
        myUseSegScale = true;
        mySegScale = UT_Vector2D(0,0);
        myDotexture = true;
        myUoff = 0;
        myTextu = UT_Vector2D(0,1);
        myUseTextVAttrib = 0;
        myTextVAttrib = "arc"_UTsh;
        myTextv = UT_Vector2D(0,1);
        myUseUpAttrib = 0;
        myUpvector = UT_Vector3D(0,1,0);
        myUpAttrib = "up"_UTsh;

    }

    explicit SOP_PolyWireParms(const SOP_PolyWireParms &) = default;
    SOP_PolyWireParms &operator=(const SOP_PolyWireParms &) = default;
    SOP_PolyWireParms(SOP_PolyWireParms &&) noexcept = default;
    SOP_PolyWireParms &operator=(SOP_PolyWireParms &&) noexcept = default;

    ~SOP_PolyWireParms() override {}

    bool operator==(const SOP_PolyWireParms &src) const
    {
        if (myGroup != src.myGroup) return false;
        if (myRadius != src.myRadius) return false;
        if (myUseScaleAttrib != src.myUseScaleAttrib) return false;
        if (myScaleAttrib != src.myScaleAttrib) return false;
        if (myJointcorrect != src.myJointcorrect) return false;
        if (myMaxscale != src.myMaxscale) return false;
        if (mySmooth != src.mySmooth) return false;
        if (myUseSmoothAttrib != src.myUseSmoothAttrib) return false;
        if (mySmoothAttrib != src.mySmoothAttrib) return false;
        if (myMaxValence != src.myMaxValence) return false;
        if (myDiv != src.myDiv) return false;
        if (myUseDivAttrib != src.myUseDivAttrib) return false;
        if (myDivAttrib != src.myDivAttrib) return false;
        if (mySegs != src.mySegs) return false;
        if (myUseSegsAttrib != src.myUseSegsAttrib) return false;
        if (mySegsAttrib != src.mySegsAttrib) return false;
        if (myUseSegScale != src.myUseSegScale) return false;
        if (mySegScale != src.mySegScale) return false;
        if (myDotexture != src.myDotexture) return false;
        if (myUoff != src.myUoff) return false;
        if (myTextu != src.myTextu) return false;
        if (myUseTextVAttrib != src.myUseTextVAttrib) return false;
        if (myTextVAttrib != src.myTextVAttrib) return false;
        if (myTextv != src.myTextv) return false;
        if (myUseUpAttrib != src.myUseUpAttrib) return false;
        if (myUpvector != src.myUpvector) return false;
        if (myUpAttrib != src.myUpAttrib) return false;

        return true;
    }
    bool operator!=(const SOP_PolyWireParms &src) const
    {
        return !operator==(src);
    }
    using UseScaleAttrib = SOP_PolyWireEnums::UseScaleAttrib;
    using UseSmoothAttrib = SOP_PolyWireEnums::UseSmoothAttrib;
    using UseDivAttrib = SOP_PolyWireEnums::UseDivAttrib;
    using UseSegsAttrib = SOP_PolyWireEnums::UseSegsAttrib;
    using UseTextVAttrib = SOP_PolyWireEnums::UseTextVAttrib;
    using UseUpAttrib = SOP_PolyWireEnums::UseUpAttrib;



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myGroup = ""_UTsh;
        if (true)
            graph->evalOpParm(myGroup, nodeidx, "group", time, 0);
        myRadius = 0.1;
        if (true)
            graph->evalOpParm(myRadius, nodeidx, "radius", time, 0);
        myUseScaleAttrib = 0;
        if (true)
            graph->evalOpParm(myUseScaleAttrib, nodeidx, "usescaleattrib", time, 0);
        myScaleAttrib = "pscale"_UTsh;
        if (true && ( (true&&!(((int64(getUseScaleAttrib())==0)))) ) )
            graph->evalOpParm(myScaleAttrib, nodeidx, "scaleattrib", time, 0);
        myJointcorrect = true;
        if (true)
            graph->evalOpParm(myJointcorrect, nodeidx, "jointcorrect", time, 0);
        myMaxscale = 2;
        if (true && ( (true&&!(((getJointcorrect()==0)))) ) )
            graph->evalOpParm(myMaxscale, nodeidx, "maxscale", time, 0);
        mySmooth = 1;
        if (true)
            graph->evalOpParm(mySmooth, nodeidx, "smooth", time, 0);
        myUseSmoothAttrib = 0;
        if (true)
            graph->evalOpParm(myUseSmoothAttrib, nodeidx, "usesmoothattrib", time, 0);
        mySmoothAttrib = "smooth"_UTsh;
        if (true && ( (true&&!(((int64(getUseSmoothAttrib())==0)))) ) )
            graph->evalOpParm(mySmoothAttrib, nodeidx, "smoothattrib", time, 0);
        myMaxValence = 25;
        if (true)
            graph->evalOpParm(myMaxValence, nodeidx, "maxvalence", time, 0);
        myDiv = 4;
        if (true)
            graph->evalOpParm(myDiv, nodeidx, "div", time, 0);
        myUseDivAttrib = 0;
        if (true)
            graph->evalOpParm(myUseDivAttrib, nodeidx, "usedivattrib", time, 0);
        myDivAttrib = "div"_UTsh;
        if (true && ( (true&&!(((int64(getUseDivAttrib())==0)))) ) )
            graph->evalOpParm(myDivAttrib, nodeidx, "divattrib", time, 0);
        mySegs = 1;
        if (true)
            graph->evalOpParm(mySegs, nodeidx, "segs", time, 0);
        myUseSegsAttrib = 0;
        if (true)
            graph->evalOpParm(myUseSegsAttrib, nodeidx, "usesegsattrib", time, 0);
        mySegsAttrib = "segs"_UTsh;
        if (true && ( (true&&!(((int64(getUseSegsAttrib())==0)))) ) )
            graph->evalOpParm(mySegsAttrib, nodeidx, "segsattrib", time, 0);
        myUseSegScale = true;
        if (true)
            graph->evalOpParm(myUseSegScale, nodeidx, "usesegscale", time, 0);
        mySegScale = UT_Vector2D(0,0);
        if (true && ( (true&&!(((getUseSegScale()==0)))) ) )
            graph->evalOpParm(mySegScale, nodeidx, "segscale", time, 0);
        myDotexture = true;
        if (true)
            graph->evalOpParm(myDotexture, nodeidx, "dotexture", time, 0);
        myUoff = 0;
        if (true && ( (true&&!(((getDotexture()==0)))) ) )
            graph->evalOpParm(myUoff, nodeidx, "uoff", time, 0);
        myTextu = UT_Vector2D(0,1);
        if (true && ( (true&&!(((getDotexture()==0)))) ) )
            graph->evalOpParm(myTextu, nodeidx, "textu", time, 0);
        myUseTextVAttrib = 0;
        if (true && ( (true&&!(((getDotexture()==0)))) ) )
            graph->evalOpParm(myUseTextVAttrib, nodeidx, "usetextvattrib", time, 0);
        myTextVAttrib = "arc"_UTsh;
        if (true && ( (true&&!(((getDotexture()==0))||((int64(getUseTextVAttrib())!=1)))) ) )
            graph->evalOpParm(myTextVAttrib, nodeidx, "textvattrib", time, 0);
        myTextv = UT_Vector2D(0,1);
        if (true && ( (true&&!(((getDotexture()==0))||((int64(getUseTextVAttrib())!=0)))) ) )
            graph->evalOpParm(myTextv, nodeidx, "textv", time, 0);
        myUseUpAttrib = 0;
        if (true)
            graph->evalOpParm(myUseUpAttrib, nodeidx, "upenable", time, 0);
        myUpvector = UT_Vector3D(0,1,0);
        if (true && ( (true&&!(((int64(getUseUpAttrib())!=1)))) ) )
            graph->evalOpParm(myUpvector, nodeidx, "upvector", time, 0);
        myUpAttrib = "up"_UTsh;
        if (true && ( (true&&!(((int64(getUseUpAttrib())!=2)))) ) )
            graph->evalOpParm(myUpAttrib, nodeidx, "upattrib", time, 0);

    }


    void loadFromOpSubclass(const LoadParms &loadparms) override
    {
        buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
    }


    void copyFrom(const OP_NodeParms *src) override
    {
        *this = *((const SOP_PolyWireParms *)src);
    }

    template <typename T>
    void
    doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(value, myGroup);
                break;
            case 1:
                coerceValue(value, myRadius);
                break;
            case 2:
                coerceValue(value, myUseScaleAttrib);
                break;
            case 3:
                coerceValue(value, myScaleAttrib);
                break;
            case 4:
                coerceValue(value, myJointcorrect);
                break;
            case 5:
                coerceValue(value, myMaxscale);
                break;
            case 6:
                coerceValue(value, mySmooth);
                break;
            case 7:
                coerceValue(value, myUseSmoothAttrib);
                break;
            case 8:
                coerceValue(value, mySmoothAttrib);
                break;
            case 9:
                coerceValue(value, myMaxValence);
                break;
            case 10:
                coerceValue(value, myDiv);
                break;
            case 11:
                coerceValue(value, myUseDivAttrib);
                break;
            case 12:
                coerceValue(value, myDivAttrib);
                break;
            case 13:
                coerceValue(value, mySegs);
                break;
            case 14:
                coerceValue(value, myUseSegsAttrib);
                break;
            case 15:
                coerceValue(value, mySegsAttrib);
                break;
            case 16:
                coerceValue(value, myUseSegScale);
                break;
            case 17:
                coerceValue(value, mySegScale);
                break;
            case 18:
                coerceValue(value, myDotexture);
                break;
            case 19:
                coerceValue(value, myUoff);
                break;
            case 20:
                coerceValue(value, myTextu);
                break;
            case 21:
                coerceValue(value, myUseTextVAttrib);
                break;
            case 22:
                coerceValue(value, myTextVAttrib);
                break;
            case 23:
                coerceValue(value, myTextv);
                break;
            case 24:
                coerceValue(value, myUseUpAttrib);
                break;
            case 25:
                coerceValue(value, myUpvector);
                break;
            case 26:
                coerceValue(value, myUpAttrib);
                break;

        }
    }

    bool isParmColorRamp(exint idx) const override
    { 
            switch (idx)
            {

            }
            return false;
    }

    void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
    { doGetParmValue(idx, instance, value); }

    template <typename T>
    void
    doSetParmValue(TempIndex idx, TempIndex instance, const T &value) 
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(myGroup, ( ( value ) ));
                break;
            case 1:
                coerceValue(myRadius, ( ( value ) ));
                break;
            case 2:
                coerceValue(myUseScaleAttrib, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 3:
                coerceValue(myScaleAttrib, ( ( value ) ));
                break;
            case 4:
                coerceValue(myJointcorrect, ( ( value ) ));
                break;
            case 5:
                coerceValue(myMaxscale, clampMinValue(1,  ( value ) ));
                break;
            case 6:
                coerceValue(mySmooth, ( ( value ) ));
                break;
            case 7:
                coerceValue(myUseSmoothAttrib, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 8:
                coerceValue(mySmoothAttrib, ( ( value ) ));
                break;
            case 9:
                coerceValue(myMaxValence, clampMinValue(0,  ( value ) ));
                break;
            case 10:
                coerceValue(myDiv, clampMinValue(3,  ( value ) ));
                break;
            case 11:
                coerceValue(myUseDivAttrib, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 12:
                coerceValue(myDivAttrib, ( ( value ) ));
                break;
            case 13:
                coerceValue(mySegs, clampMinValue(1,  ( value ) ));
                break;
            case 14:
                coerceValue(myUseSegsAttrib, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 15:
                coerceValue(mySegsAttrib, ( ( value ) ));
                break;
            case 16:
                coerceValue(myUseSegScale, ( ( value ) ));
                break;
            case 17:
                coerceValue(mySegScale, ( ( value ) ));
                break;
            case 18:
                coerceValue(myDotexture, ( ( value ) ));
                break;
            case 19:
                coerceValue(myUoff, ( ( value ) ));
                break;
            case 20:
                coerceValue(myTextu, ( ( value ) ));
                break;
            case 21:
                coerceValue(myUseTextVAttrib, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 22:
                coerceValue(myTextVAttrib, ( ( value ) ));
                break;
            case 23:
                coerceValue(myTextv, ( ( value ) ));
                break;
            case 24:
                coerceValue(myUseUpAttrib, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 25:
                coerceValue(myUpvector, ( ( value ) ));
                break;
            case 26:
                coerceValue(myUpAttrib, ( ( value ) ));
                break;

        }
    }

    void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value)  override
    { doSetParmValue(idx, instance, value); }

    exint getNestNumParms(TempIndex idx) const override
    {
        if (idx.size() == 0)
            return 27;
        switch (idx[0])
        {

        }
        // Invalid
        return 0;
    }

    const char *getNestParmName(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return 0;
        switch (fieldnum[0])
        {
            case 0:
                return "group";
            case 1:
                return "radius";
            case 2:
                return "usescaleattrib";
            case 3:
                return "scaleattrib";
            case 4:
                return "jointcorrect";
            case 5:
                return "maxscale";
            case 6:
                return "smooth";
            case 7:
                return "usesmoothattrib";
            case 8:
                return "smoothattrib";
            case 9:
                return "maxvalence";
            case 10:
                return "div";
            case 11:
                return "usedivattrib";
            case 12:
                return "divattrib";
            case 13:
                return "segs";
            case 14:
                return "usesegsattrib";
            case 15:
                return "segsattrib";
            case 16:
                return "usesegscale";
            case 17:
                return "segscale";
            case 18:
                return "dotexture";
            case 19:
                return "uoff";
            case 20:
                return "textu";
            case 21:
                return "usetextvattrib";
            case 22:
                return "textvattrib";
            case 23:
                return "textv";
            case 24:
                return "upenable";
            case 25:
                return "upvector";
            case 26:
                return "upattrib";

        }
        return 0;
    }

    ParmType getNestParmType(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return PARM_UNSUPPORTED;
        switch (fieldnum[0])
        {
            case 0:
                return PARM_STRING;
            case 1:
                return PARM_FLOAT;
            case 2:
                return PARM_INTEGER;
            case 3:
                return PARM_STRING;
            case 4:
                return PARM_INTEGER;
            case 5:
                return PARM_FLOAT;
            case 6:
                return PARM_INTEGER;
            case 7:
                return PARM_INTEGER;
            case 8:
                return PARM_STRING;
            case 9:
                return PARM_INTEGER;
            case 10:
                return PARM_INTEGER;
            case 11:
                return PARM_INTEGER;
            case 12:
                return PARM_STRING;
            case 13:
                return PARM_INTEGER;
            case 14:
                return PARM_INTEGER;
            case 15:
                return PARM_STRING;
            case 16:
                return PARM_INTEGER;
            case 17:
                return PARM_VECTOR2;
            case 18:
                return PARM_INTEGER;
            case 19:
                return PARM_FLOAT;
            case 20:
                return PARM_VECTOR2;
            case 21:
                return PARM_INTEGER;
            case 22:
                return PARM_STRING;
            case 23:
                return PARM_VECTOR2;
            case 24:
                return PARM_INTEGER;
            case 25:
                return PARM_VECTOR3;
            case 26:
                return PARM_STRING;

        }
        return PARM_UNSUPPORTED;
    }

    // Boiler plate to load individual types.
    static void  loadData(UT_IStream &is, int64 &v)
    { is.bread(&v, 1); }
    static void  loadData(UT_IStream &is, bool &v)
    { int64     iv; is.bread(&iv, 1); v = iv; }
    static void  loadData(UT_IStream &is, fpreal64 &v)
    { is.bread<fpreal64>(&v, 1); }
    static void  loadData(UT_IStream &is, UT_Vector2D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix2D &v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix3D &v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix4D &v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Vector2I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_StringHolder &v)
    { is.bread(v); }
    static void  loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
    {   UT_StringHolder   rampdata;
        loadData(is, rampdata);
        if (rampdata.isstring())
        {
            v.reset(new UT_Ramp());
            UT_IStream  istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
            v->load(istr);
        }
        else v.reset();
    }
    static void  loadData(UT_IStream &is, PRM_DataItemHandle &v)
    {   UT_StringHolder   data;
        loadData(is, data);
        if (data.isstring())
        {
            // Find the data type.
            const char *colon = UT_StringWrap(data).findChar(':');
            if (colon)
            {
                int             typelen = colon - data.buffer();
                UT_WorkBuffer   type;
                type.strncpy(data.buffer(), typelen);
                UT_IStream  istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
                
                v = PRM_DataFactory::parseBinary(type.buffer(), istr);
            }
        }
        else v.reset();
    }

    static void  saveData(std::ostream &os, int64 v)
    { UTwrite(os, &v); }
    static void  saveData(std::ostream &os, bool v)
    { int64 iv = v; UTwrite(os, &iv); }
    static void  saveData(std::ostream &os, fpreal64 v)
    { UTwrite<fpreal64>(os, &v); }
    static void  saveData(std::ostream &os, UT_Vector2D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
    static void  saveData(std::ostream &os, UT_Vector3D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); }
    static void  saveData(std::ostream &os, UT_Vector4D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
    static void  saveData(std::ostream &os, UT_Matrix2D v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix3D v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix4D v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_StringHolder s)
    { UT_StringWrap(s).saveBinary(os); }
    static void  saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) s->save(ostr);
        result = ostr.str();
        saveData(os, result);
    }
    static void  saveData(std::ostream &os, PRM_DataItemHandle s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) 
        {
            ostr << s->getDataTypeToken();
            ostr << ":";
            s->saveBinary(ostr);
        }
        result = ostr.str();
        saveData(os, result);
    }


    void         save(std::ostream &os) const
    {
        int32           v = version();
        UTwrite(os, &v);
        saveData(os, myGroup);
        saveData(os, myRadius);
        saveData(os, myUseScaleAttrib);
        saveData(os, myScaleAttrib);
        saveData(os, myJointcorrect);
        saveData(os, myMaxscale);
        saveData(os, mySmooth);
        saveData(os, myUseSmoothAttrib);
        saveData(os, mySmoothAttrib);
        saveData(os, myMaxValence);
        saveData(os, myDiv);
        saveData(os, myUseDivAttrib);
        saveData(os, myDivAttrib);
        saveData(os, mySegs);
        saveData(os, myUseSegsAttrib);
        saveData(os, mySegsAttrib);
        saveData(os, myUseSegScale);
        saveData(os, mySegScale);
        saveData(os, myDotexture);
        saveData(os, myUoff);
        saveData(os, myTextu);
        saveData(os, myUseTextVAttrib);
        saveData(os, myTextVAttrib);
        saveData(os, myTextv);
        saveData(os, myUseUpAttrib);
        saveData(os, myUpvector);
        saveData(os, myUpAttrib);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myGroup);
        loadData(is, myRadius);
        loadData(is, myUseScaleAttrib);
        loadData(is, myScaleAttrib);
        loadData(is, myJointcorrect);
        loadData(is, myMaxscale);
        loadData(is, mySmooth);
        loadData(is, myUseSmoothAttrib);
        loadData(is, mySmoothAttrib);
        loadData(is, myMaxValence);
        loadData(is, myDiv);
        loadData(is, myUseDivAttrib);
        loadData(is, myDivAttrib);
        loadData(is, mySegs);
        loadData(is, myUseSegsAttrib);
        loadData(is, mySegsAttrib);
        loadData(is, myUseSegScale);
        loadData(is, mySegScale);
        loadData(is, myDotexture);
        loadData(is, myUoff);
        loadData(is, myTextu);
        loadData(is, myUseTextVAttrib);
        loadData(is, myTextVAttrib);
        loadData(is, myTextv);
        loadData(is, myUseUpAttrib);
        loadData(is, myUpvector);
        loadData(is, myUpAttrib);

        return true;
    }

    const UT_StringHolder & getGroup() const { return myGroup; }
    void setGroup(const UT_StringHolder & val) { myGroup = val; }
    UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getRadius() const { return myRadius; }
    void setRadius(fpreal64 val) { myRadius = val; }
    fpreal64 opRadius(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRadius();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "radius", cookparms.getCookTime(), 0);
        return result;
    }
    UseScaleAttrib getUseScaleAttrib() const { return UseScaleAttrib(myUseScaleAttrib); }
    void setUseScaleAttrib(UseScaleAttrib val) { myUseScaleAttrib = int64(val); }
    UseScaleAttrib opUseScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseScaleAttrib();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "usescaleattrib", cookparms.getCookTime(), 0);
        return UseScaleAttrib(result);
    }
    const UT_StringHolder & getScaleAttrib() const { return myScaleAttrib; }
    void setScaleAttrib(const UT_StringHolder & val) { myScaleAttrib = val; }
    UT_StringHolder opScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getScaleAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "scaleattrib", cookparms.getCookTime(), 0);
        return result;
    }
    bool getJointcorrect() const { return myJointcorrect; }
    void setJointcorrect(bool val) { myJointcorrect = val; }
    bool opJointcorrect(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getJointcorrect();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "jointcorrect", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMaxscale() const { return myMaxscale; }
    void setMaxscale(fpreal64 val) { myMaxscale = val; }
    fpreal64 opMaxscale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxscale();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "maxscale", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getSmooth() const { return mySmooth; }
    void setSmooth(int64 val) { mySmooth = val; }
    int64 opSmooth(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSmooth();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "smooth", cookparms.getCookTime(), 0);
        return result;
    }
    UseSmoothAttrib getUseSmoothAttrib() const { return UseSmoothAttrib(myUseSmoothAttrib); }
    void setUseSmoothAttrib(UseSmoothAttrib val) { myUseSmoothAttrib = int64(val); }
    UseSmoothAttrib opUseSmoothAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseSmoothAttrib();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "usesmoothattrib", cookparms.getCookTime(), 0);
        return UseSmoothAttrib(result);
    }
    const UT_StringHolder & getSmoothAttrib() const { return mySmoothAttrib; }
    void setSmoothAttrib(const UT_StringHolder & val) { mySmoothAttrib = val; }
    UT_StringHolder opSmoothAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSmoothAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "smoothattrib", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getMaxValence() const { return myMaxValence; }
    void setMaxValence(int64 val) { myMaxValence = val; }
    int64 opMaxValence(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxValence();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "maxvalence", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getDiv() const { return myDiv; }
    void setDiv(int64 val) { myDiv = val; }
    int64 opDiv(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDiv();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "div", cookparms.getCookTime(), 0);
        return result;
    }
    UseDivAttrib getUseDivAttrib() const { return UseDivAttrib(myUseDivAttrib); }
    void setUseDivAttrib(UseDivAttrib val) { myUseDivAttrib = int64(val); }
    UseDivAttrib opUseDivAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseDivAttrib();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "usedivattrib", cookparms.getCookTime(), 0);
        return UseDivAttrib(result);
    }
    const UT_StringHolder & getDivAttrib() const { return myDivAttrib; }
    void setDivAttrib(const UT_StringHolder & val) { myDivAttrib = val; }
    UT_StringHolder opDivAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDivAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "divattrib", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getSegs() const { return mySegs; }
    void setSegs(int64 val) { mySegs = val; }
    int64 opSegs(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSegs();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "segs", cookparms.getCookTime(), 0);
        return result;
    }
    UseSegsAttrib getUseSegsAttrib() const { return UseSegsAttrib(myUseSegsAttrib); }
    void setUseSegsAttrib(UseSegsAttrib val) { myUseSegsAttrib = int64(val); }
    UseSegsAttrib opUseSegsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseSegsAttrib();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "usesegsattrib", cookparms.getCookTime(), 0);
        return UseSegsAttrib(result);
    }
    const UT_StringHolder & getSegsAttrib() const { return mySegsAttrib; }
    void setSegsAttrib(const UT_StringHolder & val) { mySegsAttrib = val; }
    UT_StringHolder opSegsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSegsAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "segsattrib", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseSegScale() const { return myUseSegScale; }
    void setUseSegScale(bool val) { myUseSegScale = val; }
    bool opUseSegScale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseSegScale();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usesegscale", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSegScale() const { return mySegScale; }
    void setSegScale(UT_Vector2D val) { mySegScale = val; }
    UT_Vector2D opSegScale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSegScale();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "segscale", cookparms.getCookTime(), 0);
        return result;
    }
    bool getDotexture() const { return myDotexture; }
    void setDotexture(bool val) { myDotexture = val; }
    bool opDotexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDotexture();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "dotexture", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getUoff() const { return myUoff; }
    void setUoff(fpreal64 val) { myUoff = val; }
    fpreal64 opUoff(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUoff();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "uoff", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getTextu() const { return myTextu; }
    void setTextu(UT_Vector2D val) { myTextu = val; }
    UT_Vector2D opTextu(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTextu();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "textu", cookparms.getCookTime(), 0);
        return result;
    }
    UseTextVAttrib getUseTextVAttrib() const { return UseTextVAttrib(myUseTextVAttrib); }
    void setUseTextVAttrib(UseTextVAttrib val) { myUseTextVAttrib = int64(val); }
    UseTextVAttrib opUseTextVAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseTextVAttrib();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "usetextvattrib", cookparms.getCookTime(), 0);
        return UseTextVAttrib(result);
    }
    const UT_StringHolder & getTextVAttrib() const { return myTextVAttrib; }
    void setTextVAttrib(const UT_StringHolder & val) { myTextVAttrib = val; }
    UT_StringHolder opTextVAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTextVAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "textvattrib", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getTextv() const { return myTextv; }
    void setTextv(UT_Vector2D val) { myTextv = val; }
    UT_Vector2D opTextv(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTextv();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "textv", cookparms.getCookTime(), 0);
        return result;
    }
    UseUpAttrib getUseUpAttrib() const { return UseUpAttrib(myUseUpAttrib); }
    void setUseUpAttrib(UseUpAttrib val) { myUseUpAttrib = int64(val); }
    UseUpAttrib opUseUpAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseUpAttrib();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "upenable", cookparms.getCookTime(), 0);
        return UseUpAttrib(result);
    }
    UT_Vector3D getUpvector() const { return myUpvector; }
    void setUpvector(UT_Vector3D val) { myUpvector = val; }
    UT_Vector3D opUpvector(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUpvector();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "upvector", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getUpAttrib() const { return myUpAttrib; }
    void setUpAttrib(const UT_StringHolder & val) { myUpAttrib = val; }
    UT_StringHolder opUpAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUpAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "upattrib", cookparms.getCookTime(), 0);
        return result;
    }

private:
    UT_StringHolder myGroup;
    fpreal64 myRadius;
    int64 myUseScaleAttrib;
    UT_StringHolder myScaleAttrib;
    bool myJointcorrect;
    fpreal64 myMaxscale;
    int64 mySmooth;
    int64 myUseSmoothAttrib;
    UT_StringHolder mySmoothAttrib;
    int64 myMaxValence;
    int64 myDiv;
    int64 myUseDivAttrib;
    UT_StringHolder myDivAttrib;
    int64 mySegs;
    int64 myUseSegsAttrib;
    UT_StringHolder mySegsAttrib;
    bool myUseSegScale;
    UT_Vector2D mySegScale;
    bool myDotexture;
    fpreal64 myUoff;
    UT_Vector2D myTextu;
    int64 myUseTextVAttrib;
    UT_StringHolder myTextVAttrib;
    UT_Vector2D myTextv;
    int64 myUseUpAttrib;
    UT_Vector3D myUpvector;
    UT_StringHolder myUpAttrib;

};