SOP_GroupCreate.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 <OP/OP_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_GroupCreateEnums
{
    enum class Grouptype
    {
        PRIMITIVE = 0,
        POINT,
        EDGE,
        VERTEX
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Grouptype enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Grouptype::PRIMITIVE: return "primitive"_sh;
        case Grouptype::POINT: return "point"_sh;
        case Grouptype::EDGE: return "edge"_sh;
        case Grouptype::VERTEX: return "vertex"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Mergeop
    {
        REPLACE = 0,
        UNION,
        INTERSECT,
        SUBTRACT
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Mergeop enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Mergeop::REPLACE: return "replace"_sh;
        case Mergeop::UNION: return "union"_sh;
        case Mergeop::INTERSECT: return "intersect"_sh;
        case Mergeop::SUBTRACT: return "subtract"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Boundtype
    {
        USEBBOX = 0,
        USEBSPHERE,
        USEBOBJECT,
        USEBVOLUME,
        USEBCONVEX
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Boundtype enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Boundtype::USEBBOX: return "usebbox"_sh;
        case Boundtype::USEBSPHERE: return "usebsphere"_sh;
        case Boundtype::USEBOBJECT: return "usebobject"_sh;
        case Boundtype::USEBVOLUME: return "usebvolume"_sh;
        case Boundtype::USEBCONVEX: return "usebconvex"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

}


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

    SOP_GroupCreateParms()
    {
        myGroupName = "group1"_UTsh;
        myGrouptype = 0;
        myMergeop = 0;
        myGroupBase = true;
        myBasegroup = ""_UTsh;
        myOrdered = false;
        myGeotype = 0;
        myGroupBounding = false;
        myBoundtype = 0;
        mySize = UT_Vector3D(1,1,1);
        myT = UT_Vector3D(0,0,0);
        myIncludenotwhollycontained = false;
        myIso = 0;
        myInvertvolume = false;
        myGroupNormal = false;
        myCamerapath = ""_UTsh;
        myNonplanar = false;
        myNonplanartol = 0.001;
        myDir = UT_Vector3D(0,0,1);
        myAngle = 180;
        myOppositenormals = false;
        myGroupEdges = false;
        myDominedgeangle = false;
        myMinedgeangle = 20;
        myDomaxedgeangle = false;
        myMaxedgeangle = 20;
        myEdgeAngleBetweenEdges = false;
        myDominedgelen = false;
        myMinedgelen = 0;
        myDomaxedgelen = false;
        myMaxedgelen = 0;
        myDodepth = false;
        myEdgestep = 0;
        myEdgeptgrp = "0"_UTsh;
        myUnshared = false;
        myBoundaryGroups = false;
        myGroupRandom = false;
        myGlobalseed = 1;
        myUseseedattrib = false;
        mySeedattrib = "id"_UTsh;
        myPercent = 50;

    }

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

    ~SOP_GroupCreateParms() override {}

    bool operator==(const SOP_GroupCreateParms &src) const
    {
        if (myGroupName != src.myGroupName) return false;
        if (myGrouptype != src.myGrouptype) return false;
        if (myMergeop != src.myMergeop) return false;
        if (myGroupBase != src.myGroupBase) return false;
        if (myBasegroup != src.myBasegroup) return false;
        if (myOrdered != src.myOrdered) return false;
        if (myGeotype != src.myGeotype) return false;
        if (myGroupBounding != src.myGroupBounding) return false;
        if (myBoundtype != src.myBoundtype) return false;
        if (mySize != src.mySize) return false;
        if (myT != src.myT) return false;
        if (myIncludenotwhollycontained != src.myIncludenotwhollycontained) return false;
        if (myIso != src.myIso) return false;
        if (myInvertvolume != src.myInvertvolume) return false;
        if (myGroupNormal != src.myGroupNormal) return false;
        if (myCamerapath != src.myCamerapath) return false;
        if (myNonplanar != src.myNonplanar) return false;
        if (myNonplanartol != src.myNonplanartol) return false;
        if (myDir != src.myDir) return false;
        if (myAngle != src.myAngle) return false;
        if (myOppositenormals != src.myOppositenormals) return false;
        if (myGroupEdges != src.myGroupEdges) return false;
        if (myDominedgeangle != src.myDominedgeangle) return false;
        if (myMinedgeangle != src.myMinedgeangle) return false;
        if (myDomaxedgeangle != src.myDomaxedgeangle) return false;
        if (myMaxedgeangle != src.myMaxedgeangle) return false;
        if (myEdgeAngleBetweenEdges != src.myEdgeAngleBetweenEdges) return false;
        if (myDominedgelen != src.myDominedgelen) return false;
        if (myMinedgelen != src.myMinedgelen) return false;
        if (myDomaxedgelen != src.myDomaxedgelen) return false;
        if (myMaxedgelen != src.myMaxedgelen) return false;
        if (myDodepth != src.myDodepth) return false;
        if (myEdgestep != src.myEdgestep) return false;
        if (myEdgeptgrp != src.myEdgeptgrp) return false;
        if (myUnshared != src.myUnshared) return false;
        if (myBoundaryGroups != src.myBoundaryGroups) return false;
        if (myGroupRandom != src.myGroupRandom) return false;
        if (myGlobalseed != src.myGlobalseed) return false;
        if (myUseseedattrib != src.myUseseedattrib) return false;
        if (mySeedattrib != src.mySeedattrib) return false;
        if (myPercent != src.myPercent) return false;


        if (baseGetSignature() != src.baseGetSignature()) return false;

        return true;
    }
    bool operator!=(const SOP_GroupCreateParms &src) const
    {
        return !operator==(src);
    }
    using Grouptype = SOP_GroupCreateEnums::Grouptype;
    using Mergeop = SOP_GroupCreateEnums::Mergeop;
    using Boundtype = SOP_GroupCreateEnums::Boundtype;



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myGroupName = "group1"_UTsh;
        if (true)
            graph->evalOpParm(myGroupName, nodeidx, "groupname", time, graph->isDirect()?nullptr:depnode);
        myGrouptype = 0;
        if (true)
            graph->evalOpParm(myGrouptype, nodeidx, "grouptype", time, graph->isDirect()?nullptr:depnode);
        myMergeop = 0;
        if (true)
            graph->evalOpParm(myMergeop, nodeidx, "mergeop", time, graph->isDirect()?nullptr:depnode);
        myGroupBase = true;
        if (true)
            graph->evalOpParm(myGroupBase, nodeidx, "groupbase", time, graph->isDirect()?nullptr:depnode);
        myBasegroup = ""_UTsh;
        if (true && ( (true&&!(((getGroupBase()==0)))) ) )
            graph->evalOpParm(myBasegroup, nodeidx, "basegroup", time, graph->isDirect()?nullptr:depnode);
        myOrdered = false;
        if (true && ( (true&&!(((getGroupBase()==0)))) ) )
            graph->evalOpParm(myOrdered, nodeidx, "ordered", time, graph->isDirect()?nullptr:depnode);
        myGeotype = 0;
        if (true && ( (true&&!(((getGroupBase()==0)))) ) )
            graph->evalOpParm(myGeotype, nodeidx, "geotype", time, graph->isDirect()?nullptr:depnode);
        myGroupBounding = false;
        if (true)
            graph->evalOpParm(myGroupBounding, nodeidx, "groupbounding", time, graph->isDirect()?nullptr:depnode);
        myBoundtype = 0;
        if (true && ( (true&&!(((getGroupBounding()==0)))) ) )
            graph->evalOpParm(myBoundtype, nodeidx, "boundtype", time, graph->isDirect()?nullptr:depnode);
        mySize = UT_Vector3D(1,1,1);
        if (true && ( (true&&!(((getGroupBounding()==0))||((int64(getBoundtype())!=0)&&(int64(getBoundtype())!=1)))) ) )
            graph->evalOpParm(mySize, nodeidx, "size", time, graph->isDirect()?nullptr:depnode);
        myT = UT_Vector3D(0,0,0);
        if (true && ( (true&&!(((getGroupBounding()==0))||((int64(getBoundtype())!=0)&&(int64(getBoundtype())!=1)))) ) )
            graph->evalOpParm(myT, nodeidx, "t", time, graph->isDirect()?nullptr:depnode);
        myIncludenotwhollycontained = false;
        if (true && ( (true&&!(((getGroupBounding()==0))||((int64(getBoundtype())!=0)&&(int64(getBoundtype())!=1)&&(int64(getBoundtype())!=4)))) ) )
            graph->evalOpParm(myIncludenotwhollycontained, nodeidx, "includenotwhollycontained", time, graph->isDirect()?nullptr:depnode);
        myIso = 0;
        if (true && ( (true&&!(((getGroupBounding()==0))||((int64(getBoundtype())!=3)&&(int64(getBoundtype())!=4)))) ) )
            graph->evalOpParm(myIso, nodeidx, "iso", time, graph->isDirect()?nullptr:depnode);
        myInvertvolume = false;
        if (true && ( (true&&!(((getGroupBounding()==0))||((int64(getBoundtype())!=3)&&(int64(getBoundtype())!=4)))) ) )
            graph->evalOpParm(myInvertvolume, nodeidx, "invertvolume", time, graph->isDirect()?nullptr:depnode);
        myGroupNormal = false;
        if (true && ( (true&&!(((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myGroupNormal, nodeidx, "groupnormal", time, graph->isDirect()?nullptr:depnode);
        myCamerapath = ""_UTsh;
        if (true && ( (true&&!(((int64(getGrouptype())==3))||((getGroupNormal()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myCamerapath, nodeidx, "camerapath", time, graph->isDirect()?nullptr:depnode);
        myNonplanar = false;
        if (true && ( (true&&!(((int64(getGrouptype())!=0))||((int64(getGrouptype())==3))||((getGroupNormal()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myNonplanar, nodeidx, "nonplanar", time, graph->isDirect()?nullptr:depnode);
        myNonplanartol = 0.001;
        if (true && ( (true&&!(((int64(getGrouptype())!=0))||((getNonplanar()==0))||((int64(getGrouptype())==3))||((getGroupNormal()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myNonplanartol, nodeidx, "nonplanartol", time, graph->isDirect()?nullptr:depnode);
        myDir = UT_Vector3D(0,0,1);
        if (true && ( (true&&!(((int64(getGrouptype())==0)&&(getNonplanar()==1))||((getCamerapath()!=""))||((int64(getGrouptype())==3))||((getGroupNormal()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myDir, nodeidx, "dir", time, graph->isDirect()?nullptr:depnode);
        myAngle = 180;
        if (true && ( (true&&!(((int64(getGrouptype())==0)&&(getNonplanar()==1))||((getCamerapath()!=""))||((int64(getGrouptype())==3))||((getGroupNormal()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myAngle, nodeidx, "angle", time, graph->isDirect()?nullptr:depnode);
        myOppositenormals = false;
        if (true && ( (true&&!(((int64(getGrouptype())==3))||((getGroupNormal()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myOppositenormals, nodeidx, "oppositenormals", time, graph->isDirect()?nullptr:depnode);
        myGroupEdges = false;
        if (true && ( (true&&!(((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myGroupEdges, nodeidx, "groupedges", time, graph->isDirect()?nullptr:depnode);
        myDominedgeangle = false;
        if (true && ( (true&&!(((int64(getGrouptype())==1))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myDominedgeangle, nodeidx, "dominedgeangle", time, graph->isDirect()?nullptr:depnode);
        myMinedgeangle = 20;
        if (true && ( (true&&!(((int64(getGrouptype())==1))||((getDominedgeangle()==0))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myMinedgeangle, nodeidx, "minedgeangle", time, graph->isDirect()?nullptr:depnode);
        myDomaxedgeangle = false;
        if (true && ( (true&&!(((int64(getGrouptype())==1))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myDomaxedgeangle, nodeidx, "domaxedgeangle", time, graph->isDirect()?nullptr:depnode);
        myMaxedgeangle = 20;
        if (true && ( (true&&!(((int64(getGrouptype())==1))||((getDomaxedgeangle()==0))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myMaxedgeangle, nodeidx, "maxedgeangle", time, graph->isDirect()?nullptr:depnode);
        myEdgeAngleBetweenEdges = false;
        if (true && ( (true&&!(((int64(getGrouptype())!=2))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myEdgeAngleBetweenEdges, nodeidx, "edgeanglebetweenedges", time, graph->isDirect()?nullptr:depnode);
        myDominedgelen = false;
        if (true && ( (true&&!(((int64(getGrouptype())!=2))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myDominedgelen, nodeidx, "dominedgelen", time, graph->isDirect()?nullptr:depnode);
        myMinedgelen = 0;
        if (true && ( (true&&!(((int64(getGrouptype())!=2))||((getDominedgelen()==0))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myMinedgelen, nodeidx, "minedgelen", time, graph->isDirect()?nullptr:depnode);
        myDomaxedgelen = false;
        if (true && ( (true&&!(((int64(getGrouptype())!=2))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myDomaxedgelen, nodeidx, "domaxedgelen", time, graph->isDirect()?nullptr:depnode);
        myMaxedgelen = 0;
        if (true && ( (true&&!(((int64(getGrouptype())!=2))||((getDomaxedgelen()==0))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myMaxedgelen, nodeidx, "maxedgelen", time, graph->isDirect()?nullptr:depnode);
        myDodepth = false;
        if (true && ( (true&&!(((int64(getGrouptype())!=1))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myDodepth, nodeidx, "dodepth", time, graph->isDirect()?nullptr:depnode);
        myEdgestep = 0;
        if (true && ( (true&&!(((int64(getGrouptype())!=1))||((getDodepth()==0))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myEdgestep, nodeidx, "edgestep", time, graph->isDirect()?nullptr:depnode);
        myEdgeptgrp = "0"_UTsh;
        if (true && ( (true&&!(((int64(getGrouptype())!=1))||((getDodepth()==0))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myEdgeptgrp, nodeidx, "edgeptgrp", time, graph->isDirect()?nullptr:depnode);
        myUnshared = false;
        if (true && ( (true&&!(((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myUnshared, nodeidx, "unshared", time, graph->isDirect()?nullptr:depnode);
        myBoundaryGroups = false;
        if (true && ( (true&&!(((int64(getGrouptype())!=1))||((getUnshared()==0))||((int64(getGrouptype())==3))||((getGroupEdges()==0))||((int64(getGrouptype())==3)))) ) )
            graph->evalOpParm(myBoundaryGroups, nodeidx, "boundarygroups", time, graph->isDirect()?nullptr:depnode);
        myGroupRandom = false;
        if (true)
            graph->evalOpParm(myGroupRandom, nodeidx, "grouprandom", time, graph->isDirect()?nullptr:depnode);
        myGlobalseed = 1;
        if (true && ( (true&&!(((getGroupRandom()==0)))) ) )
            graph->evalOpParm(myGlobalseed, nodeidx, "globalseed", time, graph->isDirect()?nullptr:depnode);
        myUseseedattrib = false;
        if (true && ( (true&&!(((getGroupRandom()==0)))) ) )
            graph->evalOpParm(myUseseedattrib, nodeidx, "useseedattrib", time, graph->isDirect()?nullptr:depnode);
        mySeedattrib = "id"_UTsh;
        if (true && ( (true&&!(((getUseseedattrib()==0))||((getGroupRandom()==0)))) ) )
            graph->evalOpParm(mySeedattrib, nodeidx, "seedattrib", time, graph->isDirect()?nullptr:depnode);
        myPercent = 50;
        if (true && ( (true&&!(((getGroupRandom()==0)))) ) )
            graph->evalOpParm(myPercent, nodeidx, "percent", time, graph->isDirect()?nullptr:depnode);

    }


    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_GroupCreateParms *)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, myGroupName);
                break;
            case 1:
                coerceValue(value, myGrouptype);
                break;
            case 2:
                coerceValue(value, myMergeop);
                break;
            case 3:
                coerceValue(value, myGroupBase);
                break;
            case 4:
                coerceValue(value, myBasegroup);
                break;
            case 5:
                coerceValue(value, myOrdered);
                break;
            case 6:
                coerceValue(value, myGeotype);
                break;
            case 7:
                coerceValue(value, myGroupBounding);
                break;
            case 8:
                coerceValue(value, myBoundtype);
                break;
            case 9:
                coerceValue(value, mySize);
                break;
            case 10:
                coerceValue(value, myT);
                break;
            case 11:
                coerceValue(value, myIncludenotwhollycontained);
                break;
            case 12:
                coerceValue(value, myIso);
                break;
            case 13:
                coerceValue(value, myInvertvolume);
                break;
            case 14:
                coerceValue(value, myGroupNormal);
                break;
            case 15:
                coerceValue(value, myCamerapath);
                break;
            case 16:
                coerceValue(value, myNonplanar);
                break;
            case 17:
                coerceValue(value, myNonplanartol);
                break;
            case 18:
                coerceValue(value, myDir);
                break;
            case 19:
                coerceValue(value, myAngle);
                break;
            case 20:
                coerceValue(value, myOppositenormals);
                break;
            case 21:
                coerceValue(value, myGroupEdges);
                break;
            case 22:
                coerceValue(value, myDominedgeangle);
                break;
            case 23:
                coerceValue(value, myMinedgeangle);
                break;
            case 24:
                coerceValue(value, myDomaxedgeangle);
                break;
            case 25:
                coerceValue(value, myMaxedgeangle);
                break;
            case 26:
                coerceValue(value, myEdgeAngleBetweenEdges);
                break;
            case 27:
                coerceValue(value, myDominedgelen);
                break;
            case 28:
                coerceValue(value, myMinedgelen);
                break;
            case 29:
                coerceValue(value, myDomaxedgelen);
                break;
            case 30:
                coerceValue(value, myMaxedgelen);
                break;
            case 31:
                coerceValue(value, myDodepth);
                break;
            case 32:
                coerceValue(value, myEdgestep);
                break;
            case 33:
                coerceValue(value, myEdgeptgrp);
                break;
            case 34:
                coerceValue(value, myUnshared);
                break;
            case 35:
                coerceValue(value, myBoundaryGroups);
                break;
            case 36:
                coerceValue(value, myGroupRandom);
                break;
            case 37:
                coerceValue(value, myGlobalseed);
                break;
            case 38:
                coerceValue(value, myUseseedattrib);
                break;
            case 39:
                coerceValue(value, mySeedattrib);
                break;
            case 40:
                coerceValue(value, myPercent);
                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(myGroupName, ( ( value ) ));
                break;
            case 1:
                coerceValue(myGrouptype, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;
            case 2:
                coerceValue(myMergeop, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;
            case 3:
                coerceValue(myGroupBase, ( ( value ) ));
                break;
            case 4:
                coerceValue(myBasegroup, ( ( value ) ));
                break;
            case 5:
                coerceValue(myOrdered, ( ( value ) ));
                break;
            case 6:
                coerceValue(myGeotype, ( ( value ) ));
                break;
            case 7:
                coerceValue(myGroupBounding, ( ( value ) ));
                break;
            case 8:
                coerceValue(myBoundtype, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 9:
                coerceValue(mySize, ( ( value ) ));
                break;
            case 10:
                coerceValue(myT, ( ( value ) ));
                break;
            case 11:
                coerceValue(myIncludenotwhollycontained, ( ( value ) ));
                break;
            case 12:
                coerceValue(myIso, ( ( value ) ));
                break;
            case 13:
                coerceValue(myInvertvolume, ( ( value ) ));
                break;
            case 14:
                coerceValue(myGroupNormal, ( ( value ) ));
                break;
            case 15:
                coerceValue(myCamerapath, ( ( value ) ));
                break;
            case 16:
                coerceValue(myNonplanar, ( ( value ) ));
                break;
            case 17:
                coerceValue(myNonplanartol, clampMinValue(0,  ( value ) ));
                break;
            case 18:
                coerceValue(myDir, ( ( value ) ));
                break;
            case 19:
                coerceValue(myAngle, clampMinValue(0,  clampMaxValue(180,  value ) ));
                break;
            case 20:
                coerceValue(myOppositenormals, ( ( value ) ));
                break;
            case 21:
                coerceValue(myGroupEdges, ( ( value ) ));
                break;
            case 22:
                coerceValue(myDominedgeangle, ( ( value ) ));
                break;
            case 23:
                coerceValue(myMinedgeangle, ( ( value ) ));
                break;
            case 24:
                coerceValue(myDomaxedgeangle, ( ( value ) ));
                break;
            case 25:
                coerceValue(myMaxedgeangle, ( ( value ) ));
                break;
            case 26:
                coerceValue(myEdgeAngleBetweenEdges, ( ( value ) ));
                break;
            case 27:
                coerceValue(myDominedgelen, ( ( value ) ));
                break;
            case 28:
                coerceValue(myMinedgelen, clampMinValue(0,  ( value ) ));
                break;
            case 29:
                coerceValue(myDomaxedgelen, ( ( value ) ));
                break;
            case 30:
                coerceValue(myMaxedgelen, clampMinValue(0,  ( value ) ));
                break;
            case 31:
                coerceValue(myDodepth, ( ( value ) ));
                break;
            case 32:
                coerceValue(myEdgestep, clampMinValue(0,  ( value ) ));
                break;
            case 33:
                coerceValue(myEdgeptgrp, ( ( value ) ));
                break;
            case 34:
                coerceValue(myUnshared, ( ( value ) ));
                break;
            case 35:
                coerceValue(myBoundaryGroups, ( ( value ) ));
                break;
            case 36:
                coerceValue(myGroupRandom, ( ( value ) ));
                break;
            case 37:
                coerceValue(myGlobalseed, ( ( value ) ));
                break;
            case 38:
                coerceValue(myUseseedattrib, ( ( value ) ));
                break;
            case 39:
                coerceValue(mySeedattrib, ( ( value ) ));
                break;
            case 40:
                coerceValue(myPercent, clampMinValue(0,  clampMaxValue(100,  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 41;
        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 "groupname";
            case 1:
                return "grouptype";
            case 2:
                return "mergeop";
            case 3:
                return "groupbase";
            case 4:
                return "basegroup";
            case 5:
                return "ordered";
            case 6:
                return "geotype";
            case 7:
                return "groupbounding";
            case 8:
                return "boundtype";
            case 9:
                return "size";
            case 10:
                return "t";
            case 11:
                return "includenotwhollycontained";
            case 12:
                return "iso";
            case 13:
                return "invertvolume";
            case 14:
                return "groupnormal";
            case 15:
                return "camerapath";
            case 16:
                return "nonplanar";
            case 17:
                return "nonplanartol";
            case 18:
                return "dir";
            case 19:
                return "angle";
            case 20:
                return "oppositenormals";
            case 21:
                return "groupedges";
            case 22:
                return "dominedgeangle";
            case 23:
                return "minedgeangle";
            case 24:
                return "domaxedgeangle";
            case 25:
                return "maxedgeangle";
            case 26:
                return "edgeanglebetweenedges";
            case 27:
                return "dominedgelen";
            case 28:
                return "minedgelen";
            case 29:
                return "domaxedgelen";
            case 30:
                return "maxedgelen";
            case 31:
                return "dodepth";
            case 32:
                return "edgestep";
            case 33:
                return "edgeptgrp";
            case 34:
                return "unshared";
            case 35:
                return "boundarygroups";
            case 36:
                return "grouprandom";
            case 37:
                return "globalseed";
            case 38:
                return "useseedattrib";
            case 39:
                return "seedattrib";
            case 40:
                return "percent";

        }
        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_INTEGER;
            case 2:
                return PARM_INTEGER;
            case 3:
                return PARM_INTEGER;
            case 4:
                return PARM_STRING;
            case 5:
                return PARM_INTEGER;
            case 6:
                return PARM_INTEGER;
            case 7:
                return PARM_INTEGER;
            case 8:
                return PARM_INTEGER;
            case 9:
                return PARM_VECTOR3;
            case 10:
                return PARM_VECTOR3;
            case 11:
                return PARM_INTEGER;
            case 12:
                return PARM_FLOAT;
            case 13:
                return PARM_INTEGER;
            case 14:
                return PARM_INTEGER;
            case 15:
                return PARM_STRING;
            case 16:
                return PARM_INTEGER;
            case 17:
                return PARM_FLOAT;
            case 18:
                return PARM_VECTOR3;
            case 19:
                return PARM_FLOAT;
            case 20:
                return PARM_INTEGER;
            case 21:
                return PARM_INTEGER;
            case 22:
                return PARM_INTEGER;
            case 23:
                return PARM_FLOAT;
            case 24:
                return PARM_INTEGER;
            case 25:
                return PARM_FLOAT;
            case 26:
                return PARM_INTEGER;
            case 27:
                return PARM_INTEGER;
            case 28:
                return PARM_FLOAT;
            case 29:
                return PARM_INTEGER;
            case 30:
                return PARM_FLOAT;
            case 31:
                return PARM_INTEGER;
            case 32:
                return PARM_INTEGER;
            case 33:
                return PARM_STRING;
            case 34:
                return PARM_INTEGER;
            case 35:
                return PARM_INTEGER;
            case 36:
                return PARM_INTEGER;
            case 37:
                return PARM_FLOAT;
            case 38:
                return PARM_INTEGER;
            case 39:
                return PARM_STRING;
            case 40:
                return PARM_FLOAT;

        }
        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, myGroupName);
        saveData(os, myGrouptype);
        saveData(os, myMergeop);
        saveData(os, myGroupBase);
        saveData(os, myBasegroup);
        saveData(os, myOrdered);
        saveData(os, myGeotype);
        saveData(os, myGroupBounding);
        saveData(os, myBoundtype);
        saveData(os, mySize);
        saveData(os, myT);
        saveData(os, myIncludenotwhollycontained);
        saveData(os, myIso);
        saveData(os, myInvertvolume);
        saveData(os, myGroupNormal);
        saveData(os, myCamerapath);
        saveData(os, myNonplanar);
        saveData(os, myNonplanartol);
        saveData(os, myDir);
        saveData(os, myAngle);
        saveData(os, myOppositenormals);
        saveData(os, myGroupEdges);
        saveData(os, myDominedgeangle);
        saveData(os, myMinedgeangle);
        saveData(os, myDomaxedgeangle);
        saveData(os, myMaxedgeangle);
        saveData(os, myEdgeAngleBetweenEdges);
        saveData(os, myDominedgelen);
        saveData(os, myMinedgelen);
        saveData(os, myDomaxedgelen);
        saveData(os, myMaxedgelen);
        saveData(os, myDodepth);
        saveData(os, myEdgestep);
        saveData(os, myEdgeptgrp);
        saveData(os, myUnshared);
        saveData(os, myBoundaryGroups);
        saveData(os, myGroupRandom);
        saveData(os, myGlobalseed);
        saveData(os, myUseseedattrib);
        saveData(os, mySeedattrib);
        saveData(os, myPercent);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myGroupName);
        loadData(is, myGrouptype);
        loadData(is, myMergeop);
        loadData(is, myGroupBase);
        loadData(is, myBasegroup);
        loadData(is, myOrdered);
        loadData(is, myGeotype);
        loadData(is, myGroupBounding);
        loadData(is, myBoundtype);
        loadData(is, mySize);
        loadData(is, myT);
        loadData(is, myIncludenotwhollycontained);
        loadData(is, myIso);
        loadData(is, myInvertvolume);
        loadData(is, myGroupNormal);
        loadData(is, myCamerapath);
        loadData(is, myNonplanar);
        loadData(is, myNonplanartol);
        loadData(is, myDir);
        loadData(is, myAngle);
        loadData(is, myOppositenormals);
        loadData(is, myGroupEdges);
        loadData(is, myDominedgeangle);
        loadData(is, myMinedgeangle);
        loadData(is, myDomaxedgeangle);
        loadData(is, myMaxedgeangle);
        loadData(is, myEdgeAngleBetweenEdges);
        loadData(is, myDominedgelen);
        loadData(is, myMinedgelen);
        loadData(is, myDomaxedgelen);
        loadData(is, myMaxedgelen);
        loadData(is, myDodepth);
        loadData(is, myEdgestep);
        loadData(is, myEdgeptgrp);
        loadData(is, myUnshared);
        loadData(is, myBoundaryGroups);
        loadData(is, myGroupRandom);
        loadData(is, myGlobalseed);
        loadData(is, myUseseedattrib);
        loadData(is, mySeedattrib);
        loadData(is, myPercent);

        return true;
    }

    const UT_StringHolder & getGroupName() const { return myGroupName; }
    void setGroupName(const UT_StringHolder & val) { myGroupName = val; }
    UT_StringHolder opGroupName(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroupName();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "groupname", cookparms.getCookTime(), 0);
        return result;
    }
    Grouptype getGrouptype() const { return Grouptype(myGrouptype); }
    void setGrouptype(Grouptype val) { myGrouptype = int64(val); }
    Grouptype opGrouptype(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGrouptype();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "grouptype", cookparms.getCookTime(), 0);
        return Grouptype(result);
    }
    Mergeop getMergeop() const { return Mergeop(myMergeop); }
    void setMergeop(Mergeop val) { myMergeop = int64(val); }
    Mergeop opMergeop(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMergeop();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "mergeop", cookparms.getCookTime(), 0);
        return Mergeop(result);
    }
    bool getGroupBase() const { return myGroupBase; }
    void setGroupBase(bool val) { myGroupBase = val; }
    bool opGroupBase(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroupBase();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "groupbase", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBasegroup() const { return myBasegroup; }
    void setBasegroup(const UT_StringHolder & val) { myBasegroup = val; }
    UT_StringHolder opBasegroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBasegroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "basegroup", cookparms.getCookTime(), 0);
        return result;
    }
    bool getOrdered() const { return myOrdered; }
    void setOrdered(bool val) { myOrdered = val; }
    bool opOrdered(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getOrdered();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "ordered", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getGeotype() const { return myGeotype; }
    void setGeotype(int64 val) { myGeotype = val; }
    int64 opGeotype(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGeotype();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "geotype", cookparms.getCookTime(), 0);
        return result;
    }
    bool getGroupBounding() const { return myGroupBounding; }
    void setGroupBounding(bool val) { myGroupBounding = val; }
    bool opGroupBounding(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroupBounding();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "groupbounding", cookparms.getCookTime(), 0);
        return result;
    }
    Boundtype getBoundtype() const { return Boundtype(myBoundtype); }
    void setBoundtype(Boundtype val) { myBoundtype = int64(val); }
    Boundtype opBoundtype(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBoundtype();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "boundtype", cookparms.getCookTime(), 0);
        return Boundtype(result);
    }
    UT_Vector3D getSize() const { return mySize; }
    void setSize(UT_Vector3D val) { mySize = val; }
    UT_Vector3D opSize(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSize();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "size", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getT() const { return myT; }
    void setT(UT_Vector3D val) { myT = val; }
    UT_Vector3D opT(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getT();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "t", cookparms.getCookTime(), 0);
        return result;
    }
    bool getIncludenotwhollycontained() const { return myIncludenotwhollycontained; }
    void setIncludenotwhollycontained(bool val) { myIncludenotwhollycontained = val; }
    bool opIncludenotwhollycontained(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getIncludenotwhollycontained();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "includenotwhollycontained", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getIso() const { return myIso; }
    void setIso(fpreal64 val) { myIso = val; }
    fpreal64 opIso(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getIso();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "iso", cookparms.getCookTime(), 0);
        return result;
    }
    bool getInvertvolume() const { return myInvertvolume; }
    void setInvertvolume(bool val) { myInvertvolume = val; }
    bool opInvertvolume(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getInvertvolume();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "invertvolume", cookparms.getCookTime(), 0);
        return result;
    }
    bool getGroupNormal() const { return myGroupNormal; }
    void setGroupNormal(bool val) { myGroupNormal = val; }
    bool opGroupNormal(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroupNormal();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "groupnormal", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getCamerapath() const { return myCamerapath; }
    void setCamerapath(const UT_StringHolder & val) { myCamerapath = val; }
    UT_StringHolder opCamerapath(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCamerapath();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "camerapath", cookparms.getCookTime(), 0);
        return result;
    }
    bool getNonplanar() const { return myNonplanar; }
    void setNonplanar(bool val) { myNonplanar = val; }
    bool opNonplanar(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getNonplanar();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "nonplanar", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getNonplanartol() const { return myNonplanartol; }
    void setNonplanartol(fpreal64 val) { myNonplanartol = val; }
    fpreal64 opNonplanartol(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getNonplanartol();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "nonplanartol", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getDir() const { return myDir; }
    void setDir(UT_Vector3D val) { myDir = val; }
    UT_Vector3D opDir(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDir();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "dir", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getAngle() const { return myAngle; }
    void setAngle(fpreal64 val) { myAngle = val; }
    fpreal64 opAngle(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAngle();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "angle", cookparms.getCookTime(), 0);
        return result;
    }
    bool getOppositenormals() const { return myOppositenormals; }
    void setOppositenormals(bool val) { myOppositenormals = val; }
    bool opOppositenormals(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getOppositenormals();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "oppositenormals", cookparms.getCookTime(), 0);
        return result;
    }
    bool getGroupEdges() const { return myGroupEdges; }
    void setGroupEdges(bool val) { myGroupEdges = val; }
    bool opGroupEdges(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroupEdges();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "groupedges", cookparms.getCookTime(), 0);
        return result;
    }
    bool getDominedgeangle() const { return myDominedgeangle; }
    void setDominedgeangle(bool val) { myDominedgeangle = val; }
    bool opDominedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDominedgeangle();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "dominedgeangle", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMinedgeangle() const { return myMinedgeangle; }
    void setMinedgeangle(fpreal64 val) { myMinedgeangle = val; }
    fpreal64 opMinedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMinedgeangle();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "minedgeangle", cookparms.getCookTime(), 0);
        return result;
    }
    bool getDomaxedgeangle() const { return myDomaxedgeangle; }
    void setDomaxedgeangle(bool val) { myDomaxedgeangle = val; }
    bool opDomaxedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDomaxedgeangle();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "domaxedgeangle", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMaxedgeangle() const { return myMaxedgeangle; }
    void setMaxedgeangle(fpreal64 val) { myMaxedgeangle = val; }
    fpreal64 opMaxedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxedgeangle();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "maxedgeangle", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEdgeAngleBetweenEdges() const { return myEdgeAngleBetweenEdges; }
    void setEdgeAngleBetweenEdges(bool val) { myEdgeAngleBetweenEdges = val; }
    bool opEdgeAngleBetweenEdges(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEdgeAngleBetweenEdges();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "edgeanglebetweenedges", cookparms.getCookTime(), 0);
        return result;
    }
    bool getDominedgelen() const { return myDominedgelen; }
    void setDominedgelen(bool val) { myDominedgelen = val; }
    bool opDominedgelen(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDominedgelen();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "dominedgelen", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMinedgelen() const { return myMinedgelen; }
    void setMinedgelen(fpreal64 val) { myMinedgelen = val; }
    fpreal64 opMinedgelen(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMinedgelen();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "minedgelen", cookparms.getCookTime(), 0);
        return result;
    }
    bool getDomaxedgelen() const { return myDomaxedgelen; }
    void setDomaxedgelen(bool val) { myDomaxedgelen = val; }
    bool opDomaxedgelen(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDomaxedgelen();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "domaxedgelen", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMaxedgelen() const { return myMaxedgelen; }
    void setMaxedgelen(fpreal64 val) { myMaxedgelen = val; }
    fpreal64 opMaxedgelen(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxedgelen();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "maxedgelen", cookparms.getCookTime(), 0);
        return result;
    }
    bool getDodepth() const { return myDodepth; }
    void setDodepth(bool val) { myDodepth = val; }
    bool opDodepth(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDodepth();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "dodepth", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getEdgestep() const { return myEdgestep; }
    void setEdgestep(int64 val) { myEdgestep = val; }
    int64 opEdgestep(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEdgestep();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "edgestep", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getEdgeptgrp() const { return myEdgeptgrp; }
    void setEdgeptgrp(const UT_StringHolder & val) { myEdgeptgrp = val; }
    UT_StringHolder opEdgeptgrp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEdgeptgrp();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "edgeptgrp", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUnshared() const { return myUnshared; }
    void setUnshared(bool val) { myUnshared = val; }
    bool opUnshared(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUnshared();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "unshared", cookparms.getCookTime(), 0);
        return result;
    }
    bool getBoundaryGroups() const { return myBoundaryGroups; }
    void setBoundaryGroups(bool val) { myBoundaryGroups = val; }
    bool opBoundaryGroups(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBoundaryGroups();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "boundarygroups", cookparms.getCookTime(), 0);
        return result;
    }
    bool getGroupRandom() const { return myGroupRandom; }
    void setGroupRandom(bool val) { myGroupRandom = val; }
    bool opGroupRandom(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroupRandom();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "grouprandom", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getGlobalseed() const { return myGlobalseed; }
    void setGlobalseed(fpreal64 val) { myGlobalseed = val; }
    fpreal64 opGlobalseed(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGlobalseed();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "globalseed", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseseedattrib() const { return myUseseedattrib; }
    void setUseseedattrib(bool val) { myUseseedattrib = val; }
    bool opUseseedattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseseedattrib();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "useseedattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSeedattrib() const { return mySeedattrib; }
    void setSeedattrib(const UT_StringHolder & val) { mySeedattrib = val; }
    UT_StringHolder opSeedattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSeedattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "seedattrib", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getPercent() const { return myPercent; }
    void setPercent(fpreal64 val) { myPercent = val; }
    fpreal64 opPercent(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPercent();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "percent", cookparms.getCookTime(), 0);
        return result;
    }

private:
    UT_StringHolder myGroupName;
    int64 myGrouptype;
    int64 myMergeop;
    bool myGroupBase;
    UT_StringHolder myBasegroup;
    bool myOrdered;
    int64 myGeotype;
    bool myGroupBounding;
    int64 myBoundtype;
    UT_Vector3D mySize;
    UT_Vector3D myT;
    bool myIncludenotwhollycontained;
    fpreal64 myIso;
    bool myInvertvolume;
    bool myGroupNormal;
    UT_StringHolder myCamerapath;
    bool myNonplanar;
    fpreal64 myNonplanartol;
    UT_Vector3D myDir;
    fpreal64 myAngle;
    bool myOppositenormals;
    bool myGroupEdges;
    bool myDominedgeangle;
    fpreal64 myMinedgeangle;
    bool myDomaxedgeangle;
    fpreal64 myMaxedgeangle;
    bool myEdgeAngleBetweenEdges;
    bool myDominedgelen;
    fpreal64 myMinedgelen;
    bool myDomaxedgelen;
    fpreal64 myMaxedgelen;
    bool myDodepth;
    int64 myEdgestep;
    UT_StringHolder myEdgeptgrp;
    bool myUnshared;
    bool myBoundaryGroups;
    bool myGroupRandom;
    fpreal64 myGlobalseed;
    bool myUseseedattrib;
    UT_StringHolder mySeedattrib;
    fpreal64 myPercent;

};