SOP_IsoOffsetParms.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;

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

    SOP_IsoOffsetParms()
    {
        myOutput = 1;
        myMode = 0;
        myUniformSamples = 4;
        myDivs = 10;
        mySampleDiv = 10;
        myDivSize = 0.1;
        myOverrideOutput = false;
        myIsoDiv = 10;
        myPadBounds = false;
        myOverrideBounds = false;
        myMin = -1;
        myMax = 0;
        myTol = 0.001;
        myOffset = 0;
        myLaserScan = true;
        myFixSigns = true;
        myForceBounds = true;
        myInvert = false;
        myNumNeighbour = 1;
        mySweepCount = 3;
        mySweepThreshold = 2;
        myTetraType = 0;
        myFileMode = 3;
        myFileName = "./sdf$F4.simdata"_UTsh;
        myName = ""_UTsh;
        myBuildPolySoup = false;

    }

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

    ~SOP_IsoOffsetParms() override {}

    bool operator==(const SOP_IsoOffsetParms &src) const
    {
        if (myOutput != src.myOutput) return false;
        if (myMode != src.myMode) return false;
        if (myUniformSamples != src.myUniformSamples) return false;
        if (myDivs != src.myDivs) return false;
        if (mySampleDiv != src.mySampleDiv) return false;
        if (myDivSize != src.myDivSize) return false;
        if (myOverrideOutput != src.myOverrideOutput) return false;
        if (myIsoDiv != src.myIsoDiv) return false;
        if (myPadBounds != src.myPadBounds) return false;
        if (myOverrideBounds != src.myOverrideBounds) return false;
        if (myMin != src.myMin) return false;
        if (myMax != src.myMax) return false;
        if (myTol != src.myTol) return false;
        if (myOffset != src.myOffset) return false;
        if (myLaserScan != src.myLaserScan) return false;
        if (myFixSigns != src.myFixSigns) return false;
        if (myForceBounds != src.myForceBounds) return false;
        if (myInvert != src.myInvert) return false;
        if (myNumNeighbour != src.myNumNeighbour) return false;
        if (mySweepCount != src.mySweepCount) return false;
        if (mySweepThreshold != src.mySweepThreshold) return false;
        if (myTetraType != src.myTetraType) return false;
        if (myFileMode != src.myFileMode) return false;
        if (myFileName != src.myFileName) return false;
        if (myName != src.myName) return false;
        if (myBuildPolySoup != src.myBuildPolySoup) return false;


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

        return true;
    }
    bool operator!=(const SOP_IsoOffsetParms &src) const
    {
        return !operator==(src);
    }



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myOutput = 1;
        if (true)
            graph->evalOpParm(myOutput, nodeidx, "output", time, graph->isDirect()?nullptr:depnode);
        myMode = 0;
        if (true)
            graph->evalOpParm(myMode, nodeidx, "mode", time, graph->isDirect()?nullptr:depnode);
        myUniformSamples = 4;
        if (true)
            graph->evalOpParm(myUniformSamples, nodeidx, "uniformsamples", time, graph->isDirect()?nullptr:depnode);
        myDivs = 10;
        if (true)
            graph->evalOpParm(myDivs, nodeidx, "divs", time, graph->isDirect()?nullptr:depnode);
        mySampleDiv = 10;
        if (true)
            graph->evalOpParm(mySampleDiv, nodeidx, "samplediv", time, graph->isDirect()?nullptr:depnode);
        myDivSize = 0.1;
        if (true)
            graph->evalOpParm(myDivSize, nodeidx, "divsize", time, graph->isDirect()?nullptr:depnode);
        myOverrideOutput = false;
        if (true)
            graph->evalOpParm(myOverrideOutput, nodeidx, "overrideoutput", time, graph->isDirect()?nullptr:depnode);
        myIsoDiv = 10;
        if (true)
            graph->evalOpParm(myIsoDiv, nodeidx, "isodiv", time, graph->isDirect()?nullptr:depnode);
        myPadBounds = false;
        if (true)
            graph->evalOpParm(myPadBounds, nodeidx, "padbounds", time, graph->isDirect()?nullptr:depnode);
        myOverrideBounds = false;
        if (true)
            graph->evalOpParm(myOverrideBounds, nodeidx, "overridebounds", time, graph->isDirect()?nullptr:depnode);
        myMin = -1;
        if (true)
            graph->evalOpParm(myMin, nodeidx, "min", time, graph->isDirect()?nullptr:depnode);
        myMax = 0;
        if (true)
            graph->evalOpParm(myMax, nodeidx, "max", time, graph->isDirect()?nullptr:depnode);
        myTol = 0.001;
        if (true)
            graph->evalOpParm(myTol, nodeidx, "tol", time, graph->isDirect()?nullptr:depnode);
        myOffset = 0;
        if (true)
            graph->evalOpParm(myOffset, nodeidx, "offset", time, graph->isDirect()?nullptr:depnode);
        myLaserScan = true;
        if (true)
            graph->evalOpParm(myLaserScan, nodeidx, "laserscan", time, graph->isDirect()?nullptr:depnode);
        myFixSigns = true;
        if (true)
            graph->evalOpParm(myFixSigns, nodeidx, "fixsigns", time, graph->isDirect()?nullptr:depnode);
        myForceBounds = true;
        if (true)
            graph->evalOpParm(myForceBounds, nodeidx, "forcebounds", time, graph->isDirect()?nullptr:depnode);
        myInvert = false;
        if (true)
            graph->evalOpParm(myInvert, nodeidx, "invert", time, graph->isDirect()?nullptr:depnode);
        myNumNeighbour = 1;
        if (true)
            graph->evalOpParm(myNumNeighbour, nodeidx, "numneighbour", time, graph->isDirect()?nullptr:depnode);
        mySweepCount = 3;
        if (true)
            graph->evalOpParm(mySweepCount, nodeidx, "sweepcount", time, graph->isDirect()?nullptr:depnode);
        mySweepThreshold = 2;
        if (true)
            graph->evalOpParm(mySweepThreshold, nodeidx, "sweepalpha", time, graph->isDirect()?nullptr:depnode);
        myTetraType = 0;
        if (true)
            graph->evalOpParm(myTetraType, nodeidx, "tetratype", time, graph->isDirect()?nullptr:depnode);
        myFileMode = 3;
        if (true)
            graph->evalOpParm(myFileMode, nodeidx, "filemode", time, graph->isDirect()?nullptr:depnode);
        myFileName = "./sdf$F4.simdata"_UTsh;
        if (true && ( (getFileMode()!=3) ) )
            graph->evalOpParm(myFileName, nodeidx, "filename", time, graph->isDirect()?nullptr:depnode);
        myName = ""_UTsh;
        if (true)
            graph->evalOpParm(myName, nodeidx, "name", time, graph->isDirect()?nullptr:depnode);
        myBuildPolySoup = false;
        if (true)
            graph->evalOpParm(myBuildPolySoup, nodeidx, "buildpolysoup", 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_IsoOffsetParms *)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, myOutput);
                break;
            case 1:
                coerceValue(value, myMode);
                break;
            case 2:
                coerceValue(value, myUniformSamples);
                break;
            case 3:
                coerceValue(value, myDivs);
                break;
            case 4:
                coerceValue(value, mySampleDiv);
                break;
            case 5:
                coerceValue(value, myDivSize);
                break;
            case 6:
                coerceValue(value, myOverrideOutput);
                break;
            case 7:
                coerceValue(value, myIsoDiv);
                break;
            case 8:
                coerceValue(value, myPadBounds);
                break;
            case 9:
                coerceValue(value, myOverrideBounds);
                break;
            case 10:
                coerceValue(value, myMin);
                break;
            case 11:
                coerceValue(value, myMax);
                break;
            case 12:
                coerceValue(value, myTol);
                break;
            case 13:
                coerceValue(value, myOffset);
                break;
            case 14:
                coerceValue(value, myLaserScan);
                break;
            case 15:
                coerceValue(value, myFixSigns);
                break;
            case 16:
                coerceValue(value, myForceBounds);
                break;
            case 17:
                coerceValue(value, myInvert);
                break;
            case 18:
                coerceValue(value, myNumNeighbour);
                break;
            case 19:
                coerceValue(value, mySweepCount);
                break;
            case 20:
                coerceValue(value, mySweepThreshold);
                break;
            case 21:
                coerceValue(value, myTetraType);
                break;
            case 22:
                coerceValue(value, myFileMode);
                break;
            case 23:
                coerceValue(value, myFileName);
                break;
            case 24:
                coerceValue(value, myName);
                break;
            case 25:
                coerceValue(value, myBuildPolySoup);
                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(myOutput, ( ( value ) ));
                break;
            case 1:
                coerceValue(myMode, ( ( value ) ));
                break;
            case 2:
                coerceValue(myUniformSamples, ( ( value ) ));
                break;
            case 3:
                coerceValue(myDivs, ( ( value ) ));
                break;
            case 4:
                coerceValue(mySampleDiv, ( ( value ) ));
                break;
            case 5:
                coerceValue(myDivSize, ( ( value ) ));
                break;
            case 6:
                coerceValue(myOverrideOutput, ( ( value ) ));
                break;
            case 7:
                coerceValue(myIsoDiv, ( ( value ) ));
                break;
            case 8:
                coerceValue(myPadBounds, ( ( value ) ));
                break;
            case 9:
                coerceValue(myOverrideBounds, ( ( value ) ));
                break;
            case 10:
                coerceValue(myMin, ( ( value ) ));
                break;
            case 11:
                coerceValue(myMax, ( ( value ) ));
                break;
            case 12:
                coerceValue(myTol, ( ( value ) ));
                break;
            case 13:
                coerceValue(myOffset, ( ( value ) ));
                break;
            case 14:
                coerceValue(myLaserScan, ( ( value ) ));
                break;
            case 15:
                coerceValue(myFixSigns, ( ( value ) ));
                break;
            case 16:
                coerceValue(myForceBounds, ( ( value ) ));
                break;
            case 17:
                coerceValue(myInvert, ( ( value ) ));
                break;
            case 18:
                coerceValue(myNumNeighbour, ( ( value ) ));
                break;
            case 19:
                coerceValue(mySweepCount, ( ( value ) ));
                break;
            case 20:
                coerceValue(mySweepThreshold, ( ( value ) ));
                break;
            case 21:
                coerceValue(myTetraType, ( ( value ) ));
                break;
            case 22:
                coerceValue(myFileMode, ( ( value ) ));
                break;
            case 23:
                coerceValue(myFileName, ( ( value ) ));
                break;
            case 24:
                coerceValue(myName, ( ( value ) ));
                break;
            case 25:
                coerceValue(myBuildPolySoup, ( ( 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 26;
        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 "output";
            case 1:
                return "mode";
            case 2:
                return "uniformsamples";
            case 3:
                return "divs";
            case 4:
                return "samplediv";
            case 5:
                return "divsize";
            case 6:
                return "overrideoutput";
            case 7:
                return "isodiv";
            case 8:
                return "padbounds";
            case 9:
                return "overridebounds";
            case 10:
                return "min";
            case 11:
                return "max";
            case 12:
                return "tol";
            case 13:
                return "offset";
            case 14:
                return "laserscan";
            case 15:
                return "fixsigns";
            case 16:
                return "forcebounds";
            case 17:
                return "invert";
            case 18:
                return "numneighbour";
            case 19:
                return "sweepcount";
            case 20:
                return "sweepalpha";
            case 21:
                return "tetratype";
            case 22:
                return "filemode";
            case 23:
                return "filename";
            case 24:
                return "name";
            case 25:
                return "buildpolysoup";

        }
        return 0;
    }

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

        }
        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, myOutput);
        saveData(os, myMode);
        saveData(os, myUniformSamples);
        saveData(os, myDivs);
        saveData(os, mySampleDiv);
        saveData(os, myDivSize);
        saveData(os, myOverrideOutput);
        saveData(os, myIsoDiv);
        saveData(os, myPadBounds);
        saveData(os, myOverrideBounds);
        saveData(os, myMin);
        saveData(os, myMax);
        saveData(os, myTol);
        saveData(os, myOffset);
        saveData(os, myLaserScan);
        saveData(os, myFixSigns);
        saveData(os, myForceBounds);
        saveData(os, myInvert);
        saveData(os, myNumNeighbour);
        saveData(os, mySweepCount);
        saveData(os, mySweepThreshold);
        saveData(os, myTetraType);
        saveData(os, myFileMode);
        saveData(os, myFileName);
        saveData(os, myName);
        saveData(os, myBuildPolySoup);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myOutput);
        loadData(is, myMode);
        loadData(is, myUniformSamples);
        loadData(is, myDivs);
        loadData(is, mySampleDiv);
        loadData(is, myDivSize);
        loadData(is, myOverrideOutput);
        loadData(is, myIsoDiv);
        loadData(is, myPadBounds);
        loadData(is, myOverrideBounds);
        loadData(is, myMin);
        loadData(is, myMax);
        loadData(is, myTol);
        loadData(is, myOffset);
        loadData(is, myLaserScan);
        loadData(is, myFixSigns);
        loadData(is, myForceBounds);
        loadData(is, myInvert);
        loadData(is, myNumNeighbour);
        loadData(is, mySweepCount);
        loadData(is, mySweepThreshold);
        loadData(is, myTetraType);
        loadData(is, myFileMode);
        loadData(is, myFileName);
        loadData(is, myName);
        loadData(is, myBuildPolySoup);

        return true;
    }

    int64 getOutput() const { return myOutput; }
    void setOutput(int64 val) { myOutput = val; }
    int64 opOutput(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getOutput();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "output", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getMode() const { return myMode; }
    void setMode(int64 val) { myMode = val; }
    int64 opMode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "mode", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getUniformSamples() const { return myUniformSamples; }
    void setUniformSamples(int64 val) { myUniformSamples = val; }
    int64 opUniformSamples(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUniformSamples();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "uniformsamples", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3I getDivs() const { return myDivs; }
    void setDivs(UT_Vector3I val) { myDivs = val; }
    UT_Vector3I opDivs(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDivs();
        UT_Vector3I result;
        OP_Utils::evalOpParm(result, thissop, "divs", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getSampleDiv() const { return mySampleDiv; }
    void setSampleDiv(int64 val) { mySampleDiv = val; }
    int64 opSampleDiv(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSampleDiv();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "samplediv", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getDivSize() const { return myDivSize; }
    void setDivSize(fpreal64 val) { myDivSize = val; }
    fpreal64 opDivSize(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDivSize();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "divsize", cookparms.getCookTime(), 0);
        return result;
    }
    bool getOverrideOutput() const { return myOverrideOutput; }
    void setOverrideOutput(bool val) { myOverrideOutput = val; }
    bool opOverrideOutput(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getOverrideOutput();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "overrideoutput", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3I getIsoDiv() const { return myIsoDiv; }
    void setIsoDiv(UT_Vector3I val) { myIsoDiv = val; }
    UT_Vector3I opIsoDiv(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getIsoDiv();
        UT_Vector3I result;
        OP_Utils::evalOpParm(result, thissop, "isodiv", cookparms.getCookTime(), 0);
        return result;
    }
    bool getPadBounds() const { return myPadBounds; }
    void setPadBounds(bool val) { myPadBounds = val; }
    bool opPadBounds(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPadBounds();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "padbounds", cookparms.getCookTime(), 0);
        return result;
    }
    bool getOverrideBounds() const { return myOverrideBounds; }
    void setOverrideBounds(bool val) { myOverrideBounds = val; }
    bool opOverrideBounds(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getOverrideBounds();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "overridebounds", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getMin() const { return myMin; }
    void setMin(UT_Vector3D val) { myMin = val; }
    UT_Vector3D opMin(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMin();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "min", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getMax() const { return myMax; }
    void setMax(UT_Vector3D val) { myMax = val; }
    UT_Vector3D opMax(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMax();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "max", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getTol() const { return myTol; }
    void setTol(fpreal64 val) { myTol = val; }
    fpreal64 opTol(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTol();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "tol", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getOffset() const { return myOffset; }
    void setOffset(fpreal64 val) { myOffset = val; }
    fpreal64 opOffset(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getOffset();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "offset", cookparms.getCookTime(), 0);
        return result;
    }
    bool getLaserScan() const { return myLaserScan; }
    void setLaserScan(bool val) { myLaserScan = val; }
    bool opLaserScan(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getLaserScan();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "laserscan", cookparms.getCookTime(), 0);
        return result;
    }
    bool getFixSigns() const { return myFixSigns; }
    void setFixSigns(bool val) { myFixSigns = val; }
    bool opFixSigns(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getFixSigns();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "fixsigns", cookparms.getCookTime(), 0);
        return result;
    }
    bool getForceBounds() const { return myForceBounds; }
    void setForceBounds(bool val) { myForceBounds = val; }
    bool opForceBounds(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getForceBounds();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "forcebounds", cookparms.getCookTime(), 0);
        return result;
    }
    bool getInvert() const { return myInvert; }
    void setInvert(bool val) { myInvert = val; }
    bool opInvert(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getInvert();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "invert", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getNumNeighbour() const { return myNumNeighbour; }
    void setNumNeighbour(int64 val) { myNumNeighbour = val; }
    int64 opNumNeighbour(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getNumNeighbour();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "numneighbour", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getSweepCount() const { return mySweepCount; }
    void setSweepCount(int64 val) { mySweepCount = val; }
    int64 opSweepCount(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSweepCount();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "sweepcount", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getSweepThreshold() const { return mySweepThreshold; }
    void setSweepThreshold(int64 val) { mySweepThreshold = val; }
    int64 opSweepThreshold(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSweepThreshold();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "sweepalpha", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getTetraType() const { return myTetraType; }
    void setTetraType(int64 val) { myTetraType = val; }
    int64 opTetraType(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTetraType();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "tetratype", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getFileMode() const { return myFileMode; }
    void setFileMode(int64 val) { myFileMode = val; }
    int64 opFileMode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getFileMode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "filemode", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getFileName() const { return myFileName; }
    void setFileName(const UT_StringHolder & val) { myFileName = val; }
    UT_StringHolder opFileName(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getFileName();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "filename", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getName() const { return myName; }
    void setName(const UT_StringHolder & val) { myName = val; }
    UT_StringHolder opName(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getName();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "name", cookparms.getCookTime(), 0);
        return result;
    }
    bool getBuildPolySoup() const { return myBuildPolySoup; }
    void setBuildPolySoup(bool val) { myBuildPolySoup = val; }
    bool opBuildPolySoup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBuildPolySoup();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "buildpolysoup", cookparms.getCookTime(), 0);
        return result;
    }

private:
    int64 myOutput;
    int64 myMode;
    int64 myUniformSamples;
    UT_Vector3I myDivs;
    int64 mySampleDiv;
    fpreal64 myDivSize;
    bool myOverrideOutput;
    UT_Vector3I myIsoDiv;
    bool myPadBounds;
    bool myOverrideBounds;
    UT_Vector3D myMin;
    UT_Vector3D myMax;
    fpreal64 myTol;
    fpreal64 myOffset;
    bool myLaserScan;
    bool myFixSigns;
    bool myForceBounds;
    bool myInvert;
    int64 myNumNeighbour;
    int64 mySweepCount;
    int64 mySweepThreshold;
    int64 myTetraType;
    int64 myFileMode;
    UT_StringHolder myFileName;
    UT_StringHolder myName;
    bool myBuildPolySoup;

};