35         myUseDomainU1Attrib = 0;
 
   36         myDomainU1Attrib = 
""_UTsh;
 
   39         myUseDomainU2Attrib = 0;
 
   40         myDomainU2Attrib = 
""_UTsh;
 
   43         myUseDomainV1Attrib = 0;
 
   44         myDomainV1Attrib = 
""_UTsh;
 
   47         myUseDomainV2Attrib = 0;
 
   48         myDomainV2Attrib = 
""_UTsh;
 
   49         myOnlyBreakpoints = 0;
 
   52         myAllUBreakpoints = 
false;
 
   53         myAllVBreakpoints = 
false;
 
   58         myKeepOriginal = 
false;
 
   71         if (myGroup != src.myGroup) 
return false;
 
   72         if (myArcLen != src.myArcLen) 
return false;
 
   73         if (myFirstU != src.myFirstU) 
return false;
 
   74         if (myDomainU1 != src.myDomainU1) 
return false;
 
   75         if (myUseDomainU1Attrib != src.myUseDomainU1Attrib) 
return false;
 
   76         if (myDomainU1Attrib != src.myDomainU1Attrib) 
return false;
 
   77         if (mySecondU != src.mySecondU) 
return false;
 
   78         if (myDomainU2 != src.myDomainU2) 
return false;
 
   79         if (myUseDomainU2Attrib != src.myUseDomainU2Attrib) 
return false;
 
   80         if (myDomainU2Attrib != src.myDomainU2Attrib) 
return false;
 
   81         if (myFirstV != src.myFirstV) 
return false;
 
   82         if (myDomainV1 != src.myDomainV1) 
return false;
 
   83         if (myUseDomainV1Attrib != src.myUseDomainV1Attrib) 
return false;
 
   84         if (myDomainV1Attrib != src.myDomainV1Attrib) 
return false;
 
   85         if (mySecondV != src.mySecondV) 
return false;
 
   86         if (myDomainV2 != src.myDomainV2) 
return false;
 
   87         if (myUseDomainV2Attrib != src.myUseDomainV2Attrib) 
return false;
 
   88         if (myDomainV2Attrib != src.myDomainV2Attrib) 
return false;
 
   89         if (myOnlyBreakpoints != src.myOnlyBreakpoints) 
return false;
 
   90         if (myDivsU != src.myDivsU) 
return false;
 
   91         if (myDivsV != src.myDivsV) 
return false;
 
   92         if (myAllUBreakpoints != src.myAllUBreakpoints) 
return false;
 
   93         if (myAllVBreakpoints != src.myAllVBreakpoints) 
return false;
 
   94         if (myFunction != src.myFunction) 
return false;
 
   95         if (myKeepIn != src.myKeepIn) 
return false;
 
   96         if (myKeepOut != src.myKeepOut) 
return false;
 
   97         if (myExtractOp != src.myExtractOp) 
return false;
 
   98         if (myKeepOriginal != src.myKeepOriginal) 
return false;
 
  116             graph->
evalOpParm(myGroup, nodeidx, 
"group", time, graph->
isDirect()?
nullptr:depnode);
 
  119             graph->
evalOpParm(myArcLen, nodeidx, 
"arclen", time, graph->
isDirect()?
nullptr:depnode);
 
  122             graph->
evalOpParm(myFirstU, nodeidx, 
"firstu", time, graph->
isDirect()?
nullptr:depnode);
 
  125             graph->
evalOpParm(myDomainU1, nodeidx, 
"domainu1", time, graph->
isDirect()?
nullptr:depnode);
 
  126         myUseDomainU1Attrib = 0;
 
  128             graph->
evalOpParm(myUseDomainU1Attrib, nodeidx, 
"usedomainu1attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  129         myDomainU1Attrib = 
""_UTsh;
 
  131             graph->
evalOpParm(myDomainU1Attrib, nodeidx, 
"domainu1attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  134             graph->
evalOpParm(mySecondU, nodeidx, 
"secondu", time, graph->
isDirect()?
nullptr:depnode);
 
  137             graph->
evalOpParm(myDomainU2, nodeidx, 
"domainu2", time, graph->
isDirect()?
nullptr:depnode);
 
  138         myUseDomainU2Attrib = 0;
 
  140             graph->
evalOpParm(myUseDomainU2Attrib, nodeidx, 
"usedomainu2attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  141         myDomainU2Attrib = 
""_UTsh;
 
  143             graph->
evalOpParm(myDomainU2Attrib, nodeidx, 
"domainu2attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  146             graph->
evalOpParm(myFirstV, nodeidx, 
"firstv", time, graph->
isDirect()?
nullptr:depnode);
 
  149             graph->
evalOpParm(myDomainV1, nodeidx, 
"domainv1", time, graph->
isDirect()?
nullptr:depnode);
 
  150         myUseDomainV1Attrib = 0;
 
  152             graph->
evalOpParm(myUseDomainV1Attrib, nodeidx, 
"usedomainv1attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  153         myDomainV1Attrib = 
""_UTsh;
 
  155             graph->
evalOpParm(myDomainV1Attrib, nodeidx, 
"domainv1attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  158             graph->
evalOpParm(mySecondV, nodeidx, 
"secondv", time, graph->
isDirect()?
nullptr:depnode);
 
  161             graph->
evalOpParm(myDomainV2, nodeidx, 
"domainv2", time, graph->
isDirect()?
nullptr:depnode);
 
  162         myUseDomainV2Attrib = 0;
 
  164             graph->
evalOpParm(myUseDomainV2Attrib, nodeidx, 
"usedomainv2attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  165         myDomainV2Attrib = 
""_UTsh;
 
  167             graph->
evalOpParm(myDomainV2Attrib, nodeidx, 
"domainv2attrib", time, graph->
isDirect()?
nullptr:depnode);
 
  168         myOnlyBreakpoints = 0;
 
  170             graph->
evalOpParm(myOnlyBreakpoints, nodeidx, 
"onlybreakpoints", time, graph->
isDirect()?
nullptr:depnode);
 
  172         if (
true && ( (getOnlyBreakpoints()==0) ) )
 
  173             graph->
evalOpParm(myDivsU, nodeidx, 
"divsu", time, graph->
isDirect()?
nullptr:depnode);
 
  175         if (
true && ( (getOnlyBreakpoints()==0) ) )
 
  176             graph->
evalOpParm(myDivsV, nodeidx, 
"divsv", time, graph->
isDirect()?
nullptr:depnode);
 
  177         myAllUBreakpoints = 
false;
 
  178         if (
true && ( (getOnlyBreakpoints()==1) ) )
 
  179             graph->
evalOpParm(myAllUBreakpoints, nodeidx, 
"allubreakpoints", time, graph->
isDirect()?
nullptr:depnode);
 
  180         myAllVBreakpoints = 
false;
 
  181         if (
true && ( (getOnlyBreakpoints()==1) ) )
 
  182             graph->
evalOpParm(myAllVBreakpoints, nodeidx, 
"allvbreakpoints", time, graph->
isDirect()?
nullptr:depnode);
 
  185             graph->
evalOpParm(myFunction, nodeidx, 
"stdswitcher", time, graph->
isDirect()?
nullptr:depnode);
 
  187         if (
true && ( (getFunction()==0) ) )
 
  188             graph->
evalOpParm(myKeepIn, nodeidx, 
"keepin", time, graph->
isDirect()?
nullptr:depnode);
 
  190         if (
true && ( (getFunction()==0) ) )
 
  191             graph->
evalOpParm(myKeepOut, nodeidx, 
"keepout", time, graph->
isDirect()?
nullptr:depnode);
 
  193         if (
true && ( (getFunction()==1) ) )
 
  194             graph->
evalOpParm(myExtractOp, nodeidx, 
"extractop", time, graph->
isDirect()?
nullptr:depnode);
 
  195         myKeepOriginal = 
false;
 
  196         if (
true && ( (getFunction()==1) ) )
 
  197             graph->
evalOpParm(myKeepOriginal, nodeidx, 
"keepOriginal", time, graph->
isDirect()?
nullptr:depnode);
 
  213     template <
typename T>
 
  220         if (idx.
size() != instance.
size()+1)
 
  322     { doGetParmValue(idx, instance, value); }
 
  324     { doGetParmValue(idx, instance, value); }
 
  326     { doGetParmValue(idx, instance, value); }
 
  328     { doGetParmValue(idx, instance, value); }
 
  330     { doGetParmValue(idx, instance, value); }
 
  332     { doGetParmValue(idx, instance, value); }
 
  334     { doGetParmValue(idx, instance, value); }
 
  336     { doGetParmValue(idx, instance, value); }
 
  338     { doGetParmValue(idx, instance, value); }
 
  340     { doGetParmValue(idx, instance, value); }
 
  342     { doGetParmValue(idx, instance, value); }
 
  344     template <
typename T>
 
  351         if (idx.
size() != instance.
size()+1)
 
  444     { doSetParmValue(idx, instance, value); }
 
  446     { doSetParmValue(idx, instance, value); }
 
  448     { doSetParmValue(idx, instance, value); }
 
  450     { doSetParmValue(idx, instance, value); }
 
  452     { doSetParmValue(idx, instance, value); }
 
  454     { doSetParmValue(idx, instance, value); }
 
  456     { doSetParmValue(idx, instance, value); }
 
  458     { doSetParmValue(idx, instance, value); }
 
  460     { doSetParmValue(idx, instance, value); }
 
  462     { doSetParmValue(idx, instance, value); }
 
  464     { doSetParmValue(idx, instance, value); }
 
  480         if (fieldnum.
size() < 1)
 
  493                 return "usedomainu1attrib";
 
  495                 return "domainu1attrib";
 
  501                 return "usedomainu2attrib";
 
  503                 return "domainu2attrib";
 
  509                 return "usedomainv1attrib";
 
  511                 return "domainv1attrib";
 
  517                 return "usedomainv2attrib";
 
  519                 return "domainv2attrib";
 
  521                 return "onlybreakpoints";
 
  527                 return "allubreakpoints";
 
  529                 return "allvbreakpoints";
 
  531                 return "stdswitcher";
 
  539                 return "keepOriginal";
 
  547         if (fieldnum.
size() < 1)
 
  548             return PARM_UNSUPPORTED;
 
  645         loadData(is, rampdata);
 
  663                 int             typelen = colon - data.
buffer();
 
  677     { 
int64 iv = 
v; UTwrite(os, &iv); }
 
  679     { UTwrite<fpreal64>(os, &
v); }
 
  681     { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
 
  683     { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
 
  684       UTwrite<fpreal64>(os, &v.
z()); }
 
  686     { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
 
  687       UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
 
  699         if (s) s->save(ostr);
 
  701         saveData(os, result);
 
  708             ostr << s->getDataTypeToken();
 
  713         saveData(os, result);
 
  717     void         save(std::ostream &os)
 const 
  721         saveData(os, myGroup);
 
  722         saveData(os, myArcLen);
 
  723         saveData(os, myFirstU);
 
  724         saveData(os, myDomainU1);
 
  725         saveData(os, myUseDomainU1Attrib);
 
  726         saveData(os, myDomainU1Attrib);
 
  727         saveData(os, mySecondU);
 
  728         saveData(os, myDomainU2);
 
  729         saveData(os, myUseDomainU2Attrib);
 
  730         saveData(os, myDomainU2Attrib);
 
  731         saveData(os, myFirstV);
 
  732         saveData(os, myDomainV1);
 
  733         saveData(os, myUseDomainV1Attrib);
 
  734         saveData(os, myDomainV1Attrib);
 
  735         saveData(os, mySecondV);
 
  736         saveData(os, myDomainV2);
 
  737         saveData(os, myUseDomainV2Attrib);
 
  738         saveData(os, myDomainV2Attrib);
 
  739         saveData(os, myOnlyBreakpoints);
 
  740         saveData(os, myDivsU);
 
  741         saveData(os, myDivsV);
 
  742         saveData(os, myAllUBreakpoints);
 
  743         saveData(os, myAllVBreakpoints);
 
  744         saveData(os, myFunction);
 
  745         saveData(os, myKeepIn);
 
  746         saveData(os, myKeepOut);
 
  747         saveData(os, myExtractOp);
 
  748         saveData(os, myKeepOriginal);
 
  761         loadData(is, myGroup);
 
  762         loadData(is, myArcLen);
 
  763         loadData(is, myFirstU);
 
  764         loadData(is, myDomainU1);
 
  765         loadData(is, myUseDomainU1Attrib);
 
  766         loadData(is, myDomainU1Attrib);
 
  767         loadData(is, mySecondU);
 
  768         loadData(is, myDomainU2);
 
  769         loadData(is, myUseDomainU2Attrib);
 
  770         loadData(is, myDomainU2Attrib);
 
  771         loadData(is, myFirstV);
 
  772         loadData(is, myDomainV1);
 
  773         loadData(is, myUseDomainV1Attrib);
 
  774         loadData(is, myDomainV1Attrib);
 
  775         loadData(is, mySecondV);
 
  776         loadData(is, myDomainV2);
 
  777         loadData(is, myUseDomainV2Attrib);
 
  778         loadData(is, myDomainV2Attrib);
 
  779         loadData(is, myOnlyBreakpoints);
 
  780         loadData(is, myDivsU);
 
  781         loadData(is, myDivsV);
 
  782         loadData(is, myAllUBreakpoints);
 
  783         loadData(is, myAllVBreakpoints);
 
  784         loadData(is, myFunction);
 
  785         loadData(is, myKeepIn);
 
  786         loadData(is, myKeepOut);
 
  787         loadData(is, myExtractOp);
 
  788         loadData(is, myKeepOriginal);
 
  798         if (!thissop) 
return getGroup();
 
  800         OP_Utils::evalOpParm(result, thissop, 
"group", cookparms.
getCookTime(), 0);
 
  808         if (!thissop) 
return getArcLen();
 
  810         OP_Utils::evalOpParm(result, thissop, 
"arclen", cookparms.
getCookTime(), 0);
 
  818         if (!thissop) 
return getFirstU();
 
  820         OP_Utils::evalOpParm(result, thissop, 
"firstu", cookparms.
getCookTime(), 0);
 
  828         if (!thissop) 
return getDomainU1();
 
  830         OP_Utils::evalOpParm(result, thissop, 
"domainu1", cookparms.
getCookTime(), 0);
 
  838         if (!thissop) 
return getUseDomainU1Attrib();
 
  840         OP_Utils::evalOpParm(result, thissop, 
"usedomainu1attrib", cookparms.
getCookTime(), 0);
 
  848         if (!thissop) 
return getDomainU1Attrib();
 
  850         OP_Utils::evalOpParm(result, thissop, 
"domainu1attrib", cookparms.
getCookTime(), 0);
 
  858         if (!thissop) 
return getSecondU();
 
  860         OP_Utils::evalOpParm(result, thissop, 
"secondu", cookparms.
getCookTime(), 0);
 
  868         if (!thissop) 
return getDomainU2();
 
  870         OP_Utils::evalOpParm(result, thissop, 
"domainu2", cookparms.
getCookTime(), 0);
 
  878         if (!thissop) 
return getUseDomainU2Attrib();
 
  880         OP_Utils::evalOpParm(result, thissop, 
"usedomainu2attrib", cookparms.
getCookTime(), 0);
 
  888         if (!thissop) 
return getDomainU2Attrib();
 
  890         OP_Utils::evalOpParm(result, thissop, 
"domainu2attrib", cookparms.
getCookTime(), 0);
 
  898         if (!thissop) 
return getFirstV();
 
  900         OP_Utils::evalOpParm(result, thissop, 
"firstv", cookparms.
getCookTime(), 0);
 
  908         if (!thissop) 
return getDomainV1();
 
  910         OP_Utils::evalOpParm(result, thissop, 
"domainv1", cookparms.
getCookTime(), 0);
 
  918         if (!thissop) 
return getUseDomainV1Attrib();
 
  920         OP_Utils::evalOpParm(result, thissop, 
"usedomainv1attrib", cookparms.
getCookTime(), 0);
 
  928         if (!thissop) 
return getDomainV1Attrib();
 
  930         OP_Utils::evalOpParm(result, thissop, 
"domainv1attrib", cookparms.
getCookTime(), 0);
 
  938         if (!thissop) 
return getSecondV();
 
  940         OP_Utils::evalOpParm(result, thissop, 
"secondv", cookparms.
getCookTime(), 0);
 
  948         if (!thissop) 
return getDomainV2();
 
  950         OP_Utils::evalOpParm(result, thissop, 
"domainv2", cookparms.
getCookTime(), 0);
 
  958         if (!thissop) 
return getUseDomainV2Attrib();
 
  960         OP_Utils::evalOpParm(result, thissop, 
"usedomainv2attrib", cookparms.
getCookTime(), 0);
 
  968         if (!thissop) 
return getDomainV2Attrib();
 
  970         OP_Utils::evalOpParm(result, thissop, 
"domainv2attrib", cookparms.
getCookTime(), 0);
 
  978         if (!thissop) 
return getOnlyBreakpoints();
 
  980         OP_Utils::evalOpParm(result, thissop, 
"onlybreakpoints", cookparms.
getCookTime(), 0);
 
  988         if (!thissop) 
return getDivsU();
 
  990         OP_Utils::evalOpParm(result, thissop, 
"divsu", cookparms.
getCookTime(), 0);
 
  998         if (!thissop) 
return getDivsV();
 
 1000         OP_Utils::evalOpParm(result, thissop, 
"divsv", cookparms.
getCookTime(), 0);
 
 1008         if (!thissop) 
return getAllUBreakpoints();
 
 1010         OP_Utils::evalOpParm(result, thissop, 
"allubreakpoints", cookparms.
getCookTime(), 0);
 
 1018         if (!thissop) 
return getAllVBreakpoints();
 
 1020         OP_Utils::evalOpParm(result, thissop, 
"allvbreakpoints", cookparms.
getCookTime(), 0);
 
 1028         if (!thissop) 
return getFunction();
 
 1030         OP_Utils::evalOpParm(result, thissop, 
"stdswitcher", cookparms.
getCookTime(), 0);
 
 1038         if (!thissop) 
return getKeepIn();
 
 1040         OP_Utils::evalOpParm(result, thissop, 
"keepin", cookparms.
getCookTime(), 0);
 
 1048         if (!thissop) 
return getKeepOut();
 
 1050         OP_Utils::evalOpParm(result, thissop, 
"keepout", cookparms.
getCookTime(), 0);
 
 1058         if (!thissop) 
return getExtractOp();
 
 1060         OP_Utils::evalOpParm(result, thissop, 
"extractop", cookparms.
getCookTime(), 0);
 
 1068         if (!thissop) 
return getKeepOriginal();
 
 1070         OP_Utils::evalOpParm(result, thissop, 
"keepOriginal", cookparms.
getCookTime(), 0);
 
 1079     int64 myUseDomainU1Attrib;
 
 1083     int64 myUseDomainU2Attrib;
 
 1087     int64 myUseDomainV1Attrib;
 
 1091     int64 myUseDomainV2Attrib;
 
 1093     int64 myOnlyBreakpoints;
 
 1096     bool myAllUBreakpoints;
 
 1097     bool myAllVBreakpoints;
 
 1102     bool myKeepOriginal;
 
fpreal64 getDomainU1() const 
 
void copyFrom(const OP_NodeParms *src) override
 
bool opKeepOriginal(const SOP_NodeVerb::CookParms &cookparms) const 
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
 
int64 opDivsV(const SOP_NodeVerb::CookParms &cookparms) const 
 
static void saveData(std::ostream &os, UT_Matrix2D v)
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
 
void setFunction(int64 val)
 
SOP_Node * getNode() const 
 
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
 
bool operator==(const SOP_CarveParms &src) const 
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
 
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
 
int64 opUseDomainV2Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
 
bool operator!=(const SOP_CarveParms &src) const 
 
exint bread(int32 *buffer, exint asize=1)
 
int64 getExtractOp() const 
 
GT_API const UT_StringHolder time
 
constexpr SYS_FORCE_INLINE T & y() noexcept
 
void setDomainU1Attrib(const UT_StringHolder &val)
 
static void loadData(UT_IStream &is, UT_StringHolder &v)
 
GLsizei const GLfloat * value
 
bool opKeepOut(const SOP_NodeVerb::CookParms &cookparms) const 
 
static void loadData(UT_IStream &is, fpreal64 &v)
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
 
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
 
static void saveData(std::ostream &os, int64 v)
 
static void loadData(UT_IStream &is, UT_Vector4D &v)
 
static void saveData(std::ostream &os, fpreal64 v)
 
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
 
const OP_Context & context() const 
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
 
int64 opFunction(const SOP_NodeVerb::CookParms &cookparms) const 
 
bool isParmColorRamp(exint idx) const override
 
constexpr SYS_FORCE_INLINE T & z() noexcept
 
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
 
static void saveData(std::ostream &os, UT_Vector2D v)
 
SYS_FORCE_INLINE const char * buffer() const 
 
void setUseDomainV1Attrib(int64 val)
 
void setUseDomainV2Attrib(int64 val)
 
void setDomainV2Attrib(const UT_StringHolder &val)
 
void setExtractOp(int64 val)
 
void setKeepOriginal(bool val)
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
 
An output stream object that owns its own string buffer storage. 
 
int64 opExtractOp(const SOP_NodeVerb::CookParms &cookparms) const 
 
void setDomainV1Attrib(const UT_StringHolder &val)
 
**But if you need a result
 
int64 getUseDomainV1Attrib() const 
 
static void loadData(UT_IStream &is, UT_Vector3I &v)
 
static void loadData(UT_IStream &is, UT_Matrix3D &v)
 
fpreal64 getDomainV1() const 
 
int64 opUseDomainV1Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
const UT_StringHolder & getDomainV1Attrib() const 
 
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
 
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer. 
 
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
 
static void loadData(UT_IStream &is, UT_Matrix2D &v)
 
static void saveData(std::ostream &os, UT_StringHolder s)
 
const UT_StringHolder & getGroup() const 
 
static void loadData(UT_IStream &is, bool &v)
 
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
 
int64 getUseDomainV2Attrib() const 
 
constexpr SYS_FORCE_INLINE T & x() noexcept
 
bool opSecondV(const SOP_NodeVerb::CookParms &cookparms) const 
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
 
bool load(UT_IStream &is)
 
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
 
constexpr SYS_FORCE_INLINE T & x() noexcept
 
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const 
 
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
 
void setDomainU1(fpreal64 val)
 
void setGroup(const UT_StringHolder &val)
 
void setOnlyBreakpoints(int64 val)
 
bool getKeepOriginal() const 
 
bool opFirstU(const SOP_NodeVerb::CookParms &cookparms) const 
 
static void saveData(std::ostream &os, UT_Matrix3D v)
 
UT_StringHolder opDomainV1Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
 
fpreal64 getDomainU2() const 
 
SYS_FORCE_INLINE const char * buffer() const 
 
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr. 
 
int64 getUseDomainU2Attrib() const 
 
constexpr SYS_FORCE_INLINE T & z() noexcept
 
void loadFromOpSubclass(const LoadParms &loadparms) override
 
exint getNestNumParms(TempIndex idx) const override
 
bool opSecondU(const SOP_NodeVerb::CookParms &cookparms) const 
 
const OP_GraphProxy * graph() const 
 
void setSecondV(bool val)
 
int64 getFunction() const 
 
UT_StringHolder opDomainU1Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
void setAllUBreakpoints(bool val)
 
bool opAllVBreakpoints(const SOP_NodeVerb::CookParms &cookparms) const 
 
void setDomainU2Attrib(const UT_StringHolder &val)
 
const char * getNestParmName(TempIndex fieldnum) const override
 
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
 
const UT_StringHolder & getDomainU1Attrib() const 
 
void setSecondU(bool val)
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
 
int64 opUseDomainU1Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
 
void setDomainV2(fpreal64 val)
 
bool opAllUBreakpoints(const SOP_NodeVerb::CookParms &cookparms) const 
 
int64 getOnlyBreakpoints() const 
 
void setKeepOut(bool val)
 
void saveBinary(std::ostream &os) const 
Save string to binary stream. 
 
const UT_StringHolder & getDomainV2Attrib() const 
 
static void loadData(UT_IStream &is, UT_Vector3D &v)
 
GT_API const UT_StringHolder version
 
void setDomainV1(fpreal64 val)
 
fpreal64 getDomainV2() const 
 
const UT_StringHolder & getDomainU2Attrib() const 
 
int64 getUseDomainU1Attrib() const 
 
ParmType getNestParmType(TempIndex fieldnum) const override
 
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
 
void coerceValue(T &result, const S &src) const 
 
void setAllVBreakpoints(bool val)
 
static void saveData(std::ostream &os, bool v)
 
static void saveData(std::ostream &os, UT_Matrix4D v)
 
DEP_MicroNode * depnode() const 
 
int64 opDivsU(const SOP_NodeVerb::CookParms &cookparms) const 
 
Utility class for containing a color ramp. 
 
fpreal64 opDomainV2(const SOP_NodeVerb::CookParms &cookparms) const 
 
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
 
constexpr SYS_FORCE_INLINE T & w() noexcept
 
static void loadData(UT_IStream &is, UT_Matrix4D &v)
 
virtual UT_StringHolder baseGetSignature() const 
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
 
static void loadData(UT_IStream &is, int64 &v)
 
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const 
 
bool getAllVBreakpoints() const 
 
int64 opOnlyBreakpoints(const SOP_NodeVerb::CookParms &cookparms) const 
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
 
fpreal getCookTime() const 
 
fpreal64 opDomainV1(const SOP_NodeVerb::CookParms &cookparms) const 
 
bool getAllUBreakpoints() const 
 
void setUseDomainU1Attrib(int64 val)
 
const char * findChar(int c) const 
 
bool opFirstV(const SOP_NodeVerb::CookParms &cookparms) const 
 
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
 
fpreal64 opDomainU2(const SOP_NodeVerb::CookParms &cookparms) const 
 
int64 opUseDomainU2Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
static void loadData(UT_IStream &is, UT_Vector2D &v)
 
UT_StringHolder opDomainV2Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
 
bool opArcLen(const SOP_NodeVerb::CookParms &cookparms) const 
 
constexpr SYS_FORCE_INLINE T & y() noexcept
 
void setUseDomainU2Attrib(int64 val)
 
static void loadData(UT_IStream &is, UT_Vector4I &v)
 
void setDomainU2(fpreal64 val)
 
virtual bool isDirect() const =0
Direct proxies mirror actual nodes: 
 
static void saveData(std::ostream &os, UT_Vector3D v)
 
fpreal64 opDomainU1(const SOP_NodeVerb::CookParms &cookparms) const 
 
constexpr SYS_FORCE_INLINE T & y() noexcept
 
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
 
SYS_FORCE_INLINE bool isstring() const 
 
bool opKeepIn(const SOP_NodeVerb::CookParms &cookparms) const 
 
static void loadData(UT_IStream &is, UT_Vector2I &v)
 
OP_NodeParms & operator=(const OP_NodeParms &)=default
 
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
 
static void saveData(std::ostream &os, PRM_DataItemHandle s)
 
UT_StringHolder opDomainU2Attrib(const SOP_NodeVerb::CookParms &cookparms) const 
 
static void saveData(std::ostream &os, UT_Vector4D v)
 
constexpr SYS_FORCE_INLINE T & x() noexcept
 
void save(std::ostream &os) const