SOP_VolumeResize.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_VolumeResizeEnums
{
    enum class Combine
    {
        REPLACE = 0,
        UNION,
        INTERSECT
    };

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

}


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

    SOP_VolumeResizeParms()
    {
        myGroup = ""_UTsh;
        myExtracttile = false;
        myTilecount = UT_Vector3I(2,2,2);
        myTilenum = 0;
        myCombine = 0;
        mySize = UT_Vector3D(1,1,1);
        myT = UT_Vector3D(0,0,0);
        myTileminpad = UT_Vector3I(0,0,0);
        myTilemaxpad = UT_Vector3I(0,0,0);
        myVoxelpad = UT_Vector3D(0,0,0);
        myUsepoints = true;
        myKeepdata = true;
        myAllowextrap = false;
        myUseclipplane = false;
        myClipcenter = UT_Vector3D(0,0,0);
        myClipdir = UT_Vector3D(0,0,1);
        myUsemaxres = true;
        myMaxres = UT_Vector3I(512,512,512);
        myDetect2d = true;

    }

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

    ~SOP_VolumeResizeParms() override {}

    bool operator==(const SOP_VolumeResizeParms &src) const
    {
        if (myGroup != src.myGroup) return false;
        if (myExtracttile != src.myExtracttile) return false;
        if (myTilecount != src.myTilecount) return false;
        if (myTilenum != src.myTilenum) return false;
        if (myCombine != src.myCombine) return false;
        if (mySize != src.mySize) return false;
        if (myT != src.myT) return false;
        if (myTileminpad != src.myTileminpad) return false;
        if (myTilemaxpad != src.myTilemaxpad) return false;
        if (myVoxelpad != src.myVoxelpad) return false;
        if (myUsepoints != src.myUsepoints) return false;
        if (myKeepdata != src.myKeepdata) return false;
        if (myAllowextrap != src.myAllowextrap) return false;
        if (myUseclipplane != src.myUseclipplane) return false;
        if (myClipcenter != src.myClipcenter) return false;
        if (myClipdir != src.myClipdir) return false;
        if (myUsemaxres != src.myUsemaxres) return false;
        if (myMaxres != src.myMaxres) return false;
        if (myDetect2d != src.myDetect2d) return false;


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

        return true;
    }
    bool operator!=(const SOP_VolumeResizeParms &src) const
    {
        return !operator==(src);
    }
    using Combine = SOP_VolumeResizeEnums::Combine;



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myGroup = ""_UTsh;
        if (true)
            graph->evalOpParm(myGroup, nodeidx, "group", time, graph->isDirect()?nullptr:depnode);
        myExtracttile = false;
        if (true)
            graph->evalOpParm(myExtracttile, nodeidx, "extracttile", time, graph->isDirect()?nullptr:depnode);
        myTilecount = UT_Vector3I(2,2,2);
        if (true && ( (true&&!(((getExtracttile()==0)))) ) )
            graph->evalOpParm(myTilecount, nodeidx, "tilecount", time, graph->isDirect()?nullptr:depnode);
        myTilenum = 0;
        if (true && ( (true&&!(((getExtracttile()==0)))) ) )
            graph->evalOpParm(myTilenum, nodeidx, "tilenum", time, graph->isDirect()?nullptr:depnode);
        myCombine = 0;
        if (true && ( (true&&!(((getExtracttile()==1)))) ) )
            graph->evalOpParm(myCombine, nodeidx, "combine", time, graph->isDirect()?nullptr:depnode);
        mySize = UT_Vector3D(1,1,1);
        if (true && ( (true&&!((((graph->getInput(nodeidx,1)>=0)==1))||((getExtracttile()==1)))) ) )
            graph->evalOpParm(mySize, nodeidx, "size", time, graph->isDirect()?nullptr:depnode);
        myT = UT_Vector3D(0,0,0);
        if (true && ( (true&&!((((graph->getInput(nodeidx,1)>=0)==1))||((getExtracttile()==1)))) ) )
            graph->evalOpParm(myT, nodeidx, "t", time, graph->isDirect()?nullptr:depnode);
        myTileminpad = UT_Vector3I(0,0,0);
        if (true && ( (true&&!(((getExtracttile()==0)))) ) )
            graph->evalOpParm(myTileminpad, nodeidx, "tileminpad", time, graph->isDirect()?nullptr:depnode);
        myTilemaxpad = UT_Vector3I(0,0,0);
        if (true && ( (true&&!(((getExtracttile()==0)))) ) )
            graph->evalOpParm(myTilemaxpad, nodeidx, "tilemaxpad", time, graph->isDirect()?nullptr:depnode);
        myVoxelpad = UT_Vector3D(0,0,0);
        if (true)
            graph->evalOpParm(myVoxelpad, nodeidx, "voxelpad", time, graph->isDirect()?nullptr:depnode);
        myUsepoints = true;
        if (true && ( (true&&!((((graph->getInput(nodeidx,1)>=0)==0))||((getExtracttile()==1)))) ) )
            graph->evalOpParm(myUsepoints, nodeidx, "usepoints", time, graph->isDirect()?nullptr:depnode);
        myKeepdata = true;
        if (true)
            graph->evalOpParm(myKeepdata, nodeidx, "keepdata", time, graph->isDirect()?nullptr:depnode);
        myAllowextrap = false;
        if (true && ( (true&&!(((getExtracttile()==0)))) ) )
            graph->evalOpParm(myAllowextrap, nodeidx, "allowextrap", time, graph->isDirect()?nullptr:depnode);
        myUseclipplane = false;
        if (true && ( (true&&!(((getExtracttile()==1)))) ) )
            graph->evalOpParm(myUseclipplane, nodeidx, "useclipplane", time, graph->isDirect()?nullptr:depnode);
        myClipcenter = UT_Vector3D(0,0,0);
        if (true && ( (true&&!(((getUseclipplane()==0))||((getExtracttile()==1)))) ) )
            graph->evalOpParm(myClipcenter, nodeidx, "clipcenter", time, graph->isDirect()?nullptr:depnode);
        myClipdir = UT_Vector3D(0,0,1);
        if (true && ( (true&&!(((getUseclipplane()==0))||((getExtracttile()==1)))) ) )
            graph->evalOpParm(myClipdir, nodeidx, "clipdir", time, graph->isDirect()?nullptr:depnode);
        myUsemaxres = true;
        if (true && ( (true&&!(((getExtracttile()==1)))) ) )
            graph->evalOpParm(myUsemaxres, nodeidx, "usemaxres", time, graph->isDirect()?nullptr:depnode);
        myMaxres = UT_Vector3I(512,512,512);
        if (true && ( (true&&!(((getUsemaxres()==0))||((getExtracttile()==1)))) ) )
            graph->evalOpParm(myMaxres, nodeidx, "maxres", time, graph->isDirect()?nullptr:depnode);
        myDetect2d = true;
        if (true)
            graph->evalOpParm(myDetect2d, nodeidx, "detect2d", 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_VolumeResizeParms *)src);
    }

    template <typename T>
    void
    doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(value, myGroup);
                break;
            case 1:
                coerceValue(value, myExtracttile);
                break;
            case 2:
                coerceValue(value, myTilecount);
                break;
            case 3:
                coerceValue(value, myTilenum);
                break;
            case 4:
                coerceValue(value, myCombine);
                break;
            case 5:
                coerceValue(value, mySize);
                break;
            case 6:
                coerceValue(value, myT);
                break;
            case 7:
                coerceValue(value, myTileminpad);
                break;
            case 8:
                coerceValue(value, myTilemaxpad);
                break;
            case 9:
                coerceValue(value, myVoxelpad);
                break;
            case 10:
                coerceValue(value, myUsepoints);
                break;
            case 11:
                coerceValue(value, myKeepdata);
                break;
            case 12:
                coerceValue(value, myAllowextrap);
                break;
            case 13:
                coerceValue(value, myUseclipplane);
                break;
            case 14:
                coerceValue(value, myClipcenter);
                break;
            case 15:
                coerceValue(value, myClipdir);
                break;
            case 16:
                coerceValue(value, myUsemaxres);
                break;
            case 17:
                coerceValue(value, myMaxres);
                break;
            case 18:
                coerceValue(value, myDetect2d);
                break;

        }
    }

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

            }
            return false;
    }

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

    template <typename T>
    void
    doSetParmValue(TempIndex idx, TempIndex instance, const T &value) 
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(myGroup, ( ( value ) ));
                break;
            case 1:
                coerceValue(myExtracttile, ( ( value ) ));
                break;
            case 2:
                coerceValue(myTilecount, clampMinValue(1,  ( value ) ));
                break;
            case 3:
                coerceValue(myTilenum, ( ( value ) ));
                break;
            case 4:
                coerceValue(myCombine, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 5:
                coerceValue(mySize, clampMinValue(0,  ( value ) ));
                break;
            case 6:
                coerceValue(myT, ( ( value ) ));
                break;
            case 7:
                coerceValue(myTileminpad, ( ( value ) ));
                break;
            case 8:
                coerceValue(myTilemaxpad, ( ( value ) ));
                break;
            case 9:
                coerceValue(myVoxelpad, ( ( value ) ));
                break;
            case 10:
                coerceValue(myUsepoints, ( ( value ) ));
                break;
            case 11:
                coerceValue(myKeepdata, ( ( value ) ));
                break;
            case 12:
                coerceValue(myAllowextrap, ( ( value ) ));
                break;
            case 13:
                coerceValue(myUseclipplane, ( ( value ) ));
                break;
            case 14:
                coerceValue(myClipcenter, ( ( value ) ));
                break;
            case 15:
                coerceValue(myClipdir, ( ( value ) ));
                break;
            case 16:
                coerceValue(myUsemaxres, ( ( value ) ));
                break;
            case 17:
                coerceValue(myMaxres, ( ( value ) ));
                break;
            case 18:
                coerceValue(myDetect2d, ( ( 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 19;
        switch (idx[0])
        {

        }
        // Invalid
        return 0;
    }

    const char *getNestParmName(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return 0;
        switch (fieldnum[0])
        {
            case 0:
                return "group";
            case 1:
                return "extracttile";
            case 2:
                return "tilecount";
            case 3:
                return "tilenum";
            case 4:
                return "combine";
            case 5:
                return "size";
            case 6:
                return "t";
            case 7:
                return "tileminpad";
            case 8:
                return "tilemaxpad";
            case 9:
                return "voxelpad";
            case 10:
                return "usepoints";
            case 11:
                return "keepdata";
            case 12:
                return "allowextrap";
            case 13:
                return "useclipplane";
            case 14:
                return "clipcenter";
            case 15:
                return "clipdir";
            case 16:
                return "usemaxres";
            case 17:
                return "maxres";
            case 18:
                return "detect2d";

        }
        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_VECTOR3;
            case 3:
                return PARM_INTEGER;
            case 4:
                return PARM_INTEGER;
            case 5:
                return PARM_VECTOR3;
            case 6:
                return PARM_VECTOR3;
            case 7:
                return PARM_VECTOR3;
            case 8:
                return PARM_VECTOR3;
            case 9:
                return PARM_VECTOR3;
            case 10:
                return PARM_INTEGER;
            case 11:
                return PARM_INTEGER;
            case 12:
                return PARM_INTEGER;
            case 13:
                return PARM_INTEGER;
            case 14:
                return PARM_VECTOR3;
            case 15:
                return PARM_VECTOR3;
            case 16:
                return PARM_INTEGER;
            case 17:
                return PARM_VECTOR3;
            case 18:
                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, myGroup);
        saveData(os, myExtracttile);
        saveData(os, myTilecount);
        saveData(os, myTilenum);
        saveData(os, myCombine);
        saveData(os, mySize);
        saveData(os, myT);
        saveData(os, myTileminpad);
        saveData(os, myTilemaxpad);
        saveData(os, myVoxelpad);
        saveData(os, myUsepoints);
        saveData(os, myKeepdata);
        saveData(os, myAllowextrap);
        saveData(os, myUseclipplane);
        saveData(os, myClipcenter);
        saveData(os, myClipdir);
        saveData(os, myUsemaxres);
        saveData(os, myMaxres);
        saveData(os, myDetect2d);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myGroup);
        loadData(is, myExtracttile);
        loadData(is, myTilecount);
        loadData(is, myTilenum);
        loadData(is, myCombine);
        loadData(is, mySize);
        loadData(is, myT);
        loadData(is, myTileminpad);
        loadData(is, myTilemaxpad);
        loadData(is, myVoxelpad);
        loadData(is, myUsepoints);
        loadData(is, myKeepdata);
        loadData(is, myAllowextrap);
        loadData(is, myUseclipplane);
        loadData(is, myClipcenter);
        loadData(is, myClipdir);
        loadData(is, myUsemaxres);
        loadData(is, myMaxres);
        loadData(is, myDetect2d);

        return true;
    }

    const UT_StringHolder & getGroup() const { return myGroup; }
    void setGroup(const UT_StringHolder & val) { myGroup = val; }
    UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
        return result;
    }
    bool getExtracttile() const { return myExtracttile; }
    void setExtracttile(bool val) { myExtracttile = val; }
    bool opExtracttile(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getExtracttile();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "extracttile", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3I getTilecount() const { return myTilecount; }
    void setTilecount(UT_Vector3I val) { myTilecount = val; }
    UT_Vector3I opTilecount(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTilecount();
        UT_Vector3I result;
        OP_Utils::evalOpParm(result, thissop, "tilecount", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getTilenum() const { return myTilenum; }
    void setTilenum(int64 val) { myTilenum = val; }
    int64 opTilenum(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTilenum();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "tilenum", cookparms.getCookTime(), 0);
        return result;
    }
    Combine getCombine() const { return Combine(myCombine); }
    void setCombine(Combine val) { myCombine = int64(val); }
    Combine opCombine(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCombine();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "combine", cookparms.getCookTime(), 0);
        return Combine(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;
    }
    UT_Vector3I getTileminpad() const { return myTileminpad; }
    void setTileminpad(UT_Vector3I val) { myTileminpad = val; }
    UT_Vector3I opTileminpad(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTileminpad();
        UT_Vector3I result;
        OP_Utils::evalOpParm(result, thissop, "tileminpad", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3I getTilemaxpad() const { return myTilemaxpad; }
    void setTilemaxpad(UT_Vector3I val) { myTilemaxpad = val; }
    UT_Vector3I opTilemaxpad(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTilemaxpad();
        UT_Vector3I result;
        OP_Utils::evalOpParm(result, thissop, "tilemaxpad", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getVoxelpad() const { return myVoxelpad; }
    void setVoxelpad(UT_Vector3D val) { myVoxelpad = val; }
    UT_Vector3D opVoxelpad(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVoxelpad();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "voxelpad", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUsepoints() const { return myUsepoints; }
    void setUsepoints(bool val) { myUsepoints = val; }
    bool opUsepoints(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUsepoints();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usepoints", cookparms.getCookTime(), 0);
        return result;
    }
    bool getKeepdata() const { return myKeepdata; }
    void setKeepdata(bool val) { myKeepdata = val; }
    bool opKeepdata(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getKeepdata();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "keepdata", cookparms.getCookTime(), 0);
        return result;
    }
    bool getAllowextrap() const { return myAllowextrap; }
    void setAllowextrap(bool val) { myAllowextrap = val; }
    bool opAllowextrap(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAllowextrap();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "allowextrap", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseclipplane() const { return myUseclipplane; }
    void setUseclipplane(bool val) { myUseclipplane = val; }
    bool opUseclipplane(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseclipplane();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "useclipplane", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getClipcenter() const { return myClipcenter; }
    void setClipcenter(UT_Vector3D val) { myClipcenter = val; }
    UT_Vector3D opClipcenter(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getClipcenter();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "clipcenter", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getClipdir() const { return myClipdir; }
    void setClipdir(UT_Vector3D val) { myClipdir = val; }
    UT_Vector3D opClipdir(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getClipdir();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "clipdir", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUsemaxres() const { return myUsemaxres; }
    void setUsemaxres(bool val) { myUsemaxres = val; }
    bool opUsemaxres(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUsemaxres();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usemaxres", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3I getMaxres() const { return myMaxres; }
    void setMaxres(UT_Vector3I val) { myMaxres = val; }
    UT_Vector3I opMaxres(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxres();
        UT_Vector3I result;
        OP_Utils::evalOpParm(result, thissop, "maxres", cookparms.getCookTime(), 0);
        return result;
    }
    bool getDetect2d() const { return myDetect2d; }
    void setDetect2d(bool val) { myDetect2d = val; }
    bool opDetect2d(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDetect2d();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "detect2d", cookparms.getCookTime(), 0);
        return result;
    }

private:
    UT_StringHolder myGroup;
    bool myExtracttile;
    UT_Vector3I myTilecount;
    int64 myTilenum;
    int64 myCombine;
    UT_Vector3D mySize;
    UT_Vector3D myT;
    UT_Vector3I myTileminpad;
    UT_Vector3I myTilemaxpad;
    UT_Vector3D myVoxelpad;
    bool myUsepoints;
    bool myKeepdata;
    bool myAllowextrap;
    bool myUseclipplane;
    UT_Vector3D myClipcenter;
    UT_Vector3D myClipdir;
    bool myUsemaxres;
    UT_Vector3I myMaxres;
    bool myDetect2d;

};