23 namespace SOP_TangentFieldEnums
62 myCurvatureWeight = 0.1;
63 myFlipCurvatureAxes = 0;
66 myGuideAttrib =
""_UTsh;
67 myFieldAttrib =
"field"_UTsh;
68 myNormalizeField =
true;
70 myUseSingularGroup =
false;
71 mySingularGroup =
"singular"_UTsh;
72 myUsePositiveSingularGroup =
false;
73 myPositiveSingularGroup =
"positive_singular"_UTsh;
74 myUseNegativeSingularGroup =
false;
75 myNegativeSingularGroup =
"negative_singular"_UTsh;
76 myUseDiscontinuitiesGroup =
false;
77 myDiscontinuities =
"discontinuities"_UTsh;
79 myShowNormalized =
false;
80 myShowPrescaled =
true;
82 myShowSingularities =
true;
83 myGuideAttribWeight = 0;
96 if (myGroup != src.myGroup)
return false;
97 if (myCarrier != src.myCarrier)
return false;
98 if (myDirections != src.myDirections)
return false;
99 if (myRotation != src.myRotation)
return false;
100 if (myCurvatureWeight != src.myCurvatureWeight)
return false;
101 if (myFlipCurvatureAxes != src.myFlipCurvatureAxes)
return false;
102 if (myBoundaryWeight != src.myBoundaryWeight)
return false;
103 if (myBoundaryRot != src.myBoundaryRot)
return false;
104 if (myGuideAttrib != src.myGuideAttrib)
return false;
105 if (myFieldAttrib != src.myFieldAttrib)
return false;
106 if (myNormalizeField != src.myNormalizeField)
return false;
107 if (myOutputMode != src.myOutputMode)
return false;
108 if (myUseSingularGroup != src.myUseSingularGroup)
return false;
109 if (mySingularGroup != src.mySingularGroup)
return false;
110 if (myUsePositiveSingularGroup != src.myUsePositiveSingularGroup)
return false;
111 if (myPositiveSingularGroup != src.myPositiveSingularGroup)
return false;
112 if (myUseNegativeSingularGroup != src.myUseNegativeSingularGroup)
return false;
113 if (myNegativeSingularGroup != src.myNegativeSingularGroup)
return false;
114 if (myUseDiscontinuitiesGroup != src.myUseDiscontinuitiesGroup)
return false;
115 if (myDiscontinuities != src.myDiscontinuities)
return false;
116 if (myShowField != src.myShowField)
return false;
117 if (myShowNormalized != src.myShowNormalized)
return false;
118 if (myShowPrescaled != src.myShowPrescaled)
return false;
119 if (myVectorscale != src.myVectorscale)
return false;
120 if (myShowSingularities != src.myShowSingularities)
return false;
121 if (myGuideAttribWeight != src.myGuideAttribWeight)
return false;
140 graph->
evalOpParm(myGroup, nodeidx,
"group", time, 0);
143 graph->
evalOpParm(myCarrier, nodeidx,
"carrier", time, 0);
146 graph->
evalOpParm(myDirections, nodeidx,
"directions", time, 0);
149 graph->
evalOpParm(myRotation, nodeidx,
"rotation", time, 0);
150 myCurvatureWeight = 0.1;
151 if (
true && ( (
true&&!(((
int64(getDirections())==1)))) ) )
152 graph->
evalOpParm(myCurvatureWeight, nodeidx,
"curvatureweight", time, 0);
153 myFlipCurvatureAxes = 0;
154 if (
true && ( (
true&&!(((getCurvatureWeight()==0)))) ) )
155 graph->
evalOpParm(myFlipCurvatureAxes, nodeidx,
"flipcurvatureaxes", time, 0);
156 myBoundaryWeight = 0;
158 graph->
evalOpParm(myBoundaryWeight, nodeidx,
"boundaryweight", time, 0);
160 if (
true && ( (
true&&!(((getBoundaryWeight()==0)))) ) )
161 graph->
evalOpParm(myBoundaryRot, nodeidx,
"boundaryRot", time, 0);
162 myGuideAttrib =
""_UTsh;
164 graph->
evalOpParm(myGuideAttrib, nodeidx,
"guideattrib", time, 0);
165 myFieldAttrib =
"field"_UTsh;
167 graph->
evalOpParm(myFieldAttrib, nodeidx,
"fieldattrib", time, 0);
168 myNormalizeField =
true;
170 graph->
evalOpParm(myNormalizeField, nodeidx,
"normalizefield", time, 0);
172 if (
true && ( (
true&&!(((
int64(getDirections())==1)))) ) )
173 graph->
evalOpParm(myOutputMode, nodeidx,
"outputmode", time, 0);
174 myUseSingularGroup =
false;
176 graph->
evalOpParm(myUseSingularGroup, nodeidx,
"usesingulargroup", time, 0);
177 mySingularGroup =
"singular"_UTsh;
178 if (
true && ( (
true&&!(((getUseSingularGroup()==0)))) ) )
179 graph->
evalOpParm(mySingularGroup, nodeidx,
"singulargroup", time, 0);
180 myUsePositiveSingularGroup =
false;
182 graph->
evalOpParm(myUsePositiveSingularGroup, nodeidx,
"usepositivesingulargroup", time, 0);
183 myPositiveSingularGroup =
"positive_singular"_UTsh;
184 if (
true && ( (
true&&!(((getUsePositiveSingularGroup()==0)))) ) )
185 graph->
evalOpParm(myPositiveSingularGroup, nodeidx,
"positivesingulargroup", time, 0);
186 myUseNegativeSingularGroup =
false;
188 graph->
evalOpParm(myUseNegativeSingularGroup, nodeidx,
"usenegativesingulargroup", time, 0);
189 myNegativeSingularGroup =
"negative_singular"_UTsh;
190 if (
true && ( (
true&&!(((getUseNegativeSingularGroup()==0)))) ) )
191 graph->
evalOpParm(myNegativeSingularGroup, nodeidx,
"negativesingulargroup", time, 0);
192 myUseDiscontinuitiesGroup =
false;
194 graph->
evalOpParm(myUseDiscontinuitiesGroup, nodeidx,
"usediscontinuitiesgroup", time, 0);
195 myDiscontinuities =
"discontinuities"_UTsh;
196 if (
true && ( (
true&&!(((getUseDiscontinuitiesGroup()==0)))) ) )
197 graph->
evalOpParm(myDiscontinuities, nodeidx,
"discontinuities", time, 0);
200 graph->
evalOpParm(myShowField, nodeidx,
"showfield", time, 0);
201 myShowNormalized =
false;
202 if (
true && ( (
true&&!(((getShowField()==0)))) ) )
203 graph->
evalOpParm(myShowNormalized, nodeidx,
"shownormalized", time, 0);
204 myShowPrescaled =
true;
206 graph->
evalOpParm(myShowPrescaled, nodeidx,
"showprescaled", time, 0);
208 if (
true && ( (
true&&!(((getShowField()==0)))) ) )
209 graph->
evalOpParm(myVectorscale, nodeidx,
"vectorscale", time, 0);
210 myShowSingularities =
true;
212 graph->
evalOpParm(myShowSingularities, nodeidx,
"showsingularities", time, 0);
213 myGuideAttribWeight = 0;
214 if (
true && ( (
true&&!(((getGuideAttrib()==
"")))) ) )
215 graph->
evalOpParm(myGuideAttribWeight, nodeidx,
"guideattribweight", time, 0);
231 template <
typename T>
238 if (idx.
size() != instance.
size()+1)
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 { doGetParmValue(idx, instance, value); }
346 { doGetParmValue(idx, instance, value); }
348 { doGetParmValue(idx, instance, value); }
350 { doGetParmValue(idx, instance, value); }
352 { doGetParmValue(idx, instance, value); }
354 { doGetParmValue(idx, instance, value); }
356 template <
typename T>
363 if (idx.
size() != instance.
size()+1)
410 coerceValue(myUsePositiveSingularGroup, ( ( value ) ));
413 coerceValue(myPositiveSingularGroup, ( ( value ) ));
416 coerceValue(myUseNegativeSingularGroup, ( ( value ) ));
419 coerceValue(myNegativeSingularGroup, ( ( value ) ));
422 coerceValue(myUseDiscontinuitiesGroup, ( ( 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); }
466 { doSetParmValue(idx, instance, value); }
468 { doSetParmValue(idx, instance, value); }
470 { doSetParmValue(idx, instance, value); }
486 if (fieldnum.
size() < 1)
499 return "curvatureweight";
501 return "flipcurvatureaxes";
503 return "boundaryweight";
505 return "boundaryRot";
507 return "guideattrib";
509 return "fieldattrib";
511 return "normalizefield";
515 return "usesingulargroup";
517 return "singulargroup";
519 return "usepositivesingulargroup";
521 return "positivesingulargroup";
523 return "usenegativesingulargroup";
525 return "negativesingulargroup";
527 return "usediscontinuitiesgroup";
529 return "discontinuities";
533 return "shownormalized";
535 return "showprescaled";
537 return "vectorscale";
539 return "showsingularities";
541 return "guideattribweight";
549 if (fieldnum.
size() < 1)
550 return PARM_UNSUPPORTED;
626 {
for (
int r = 0;
r < 2;
r++)
for (
int c = 0; c < 2; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
628 {
for (
int r = 0;
r < 3;
r++)
for (
int c = 0; c < 3; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
630 {
for (
int r = 0;
r < 4;
r++)
for (
int c = 0; c < 4; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
643 loadData(is, rampdata);
661 int typelen = colon - data.
buffer();
675 {
int64 iv =
v; UTwrite(os, &iv); }
677 { UTwrite<fpreal64>(os, &
v); }
679 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
681 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
682 UTwrite<fpreal64>(os, &v.
z()); }
684 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
685 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
697 if (s) s->save(ostr);
699 saveData(os, result);
706 ostr << s->getDataTypeToken();
711 saveData(os, result);
715 void save(std::ostream &os)
const
719 saveData(os, myGroup);
720 saveData(os, myCarrier);
721 saveData(os, myDirections);
722 saveData(os, myRotation);
723 saveData(os, myCurvatureWeight);
724 saveData(os, myFlipCurvatureAxes);
725 saveData(os, myBoundaryWeight);
726 saveData(os, myBoundaryRot);
727 saveData(os, myGuideAttrib);
728 saveData(os, myFieldAttrib);
729 saveData(os, myNormalizeField);
730 saveData(os, myOutputMode);
731 saveData(os, myUseSingularGroup);
732 saveData(os, mySingularGroup);
733 saveData(os, myUsePositiveSingularGroup);
734 saveData(os, myPositiveSingularGroup);
735 saveData(os, myUseNegativeSingularGroup);
736 saveData(os, myNegativeSingularGroup);
737 saveData(os, myUseDiscontinuitiesGroup);
738 saveData(os, myDiscontinuities);
739 saveData(os, myShowField);
740 saveData(os, myShowNormalized);
741 saveData(os, myShowPrescaled);
742 saveData(os, myVectorscale);
743 saveData(os, myShowSingularities);
744 saveData(os, myGuideAttribWeight);
757 loadData(is, myGroup);
758 loadData(is, myCarrier);
759 loadData(is, myDirections);
760 loadData(is, myRotation);
761 loadData(is, myCurvatureWeight);
762 loadData(is, myFlipCurvatureAxes);
763 loadData(is, myBoundaryWeight);
764 loadData(is, myBoundaryRot);
765 loadData(is, myGuideAttrib);
766 loadData(is, myFieldAttrib);
767 loadData(is, myNormalizeField);
768 loadData(is, myOutputMode);
769 loadData(is, myUseSingularGroup);
770 loadData(is, mySingularGroup);
771 loadData(is, myUsePositiveSingularGroup);
772 loadData(is, myPositiveSingularGroup);
773 loadData(is, myUseNegativeSingularGroup);
774 loadData(is, myNegativeSingularGroup);
775 loadData(is, myUseDiscontinuitiesGroup);
776 loadData(is, myDiscontinuities);
777 loadData(is, myShowField);
778 loadData(is, myShowNormalized);
779 loadData(is, myShowPrescaled);
780 loadData(is, myVectorscale);
781 loadData(is, myShowSingularities);
782 loadData(is, myGuideAttribWeight);
792 if (!thissop)
return getGroup();
794 OP_Utils::evalOpParm(result, thissop,
"group", cookparms.
getCookTime(), 0);
802 if (!thissop)
return getCarrier();
804 OP_Utils::evalOpParm(result, thissop,
"carrier", cookparms.
getCookTime(), 0);
812 if (!thissop)
return getDirections();
814 OP_Utils::evalOpParm(result, thissop,
"directions", cookparms.
getCookTime(), 0);
822 if (!thissop)
return getRotation();
824 OP_Utils::evalOpParm(result, thissop,
"rotation", cookparms.
getCookTime(), 0);
832 if (!thissop)
return getCurvatureWeight();
834 OP_Utils::evalOpParm(result, thissop,
"curvatureweight", cookparms.
getCookTime(), 0);
842 if (!thissop)
return getFlipCurvatureAxes();
844 OP_Utils::evalOpParm(result, thissop,
"flipcurvatureaxes", cookparms.
getCookTime(), 0);
852 if (!thissop)
return getBoundaryWeight();
854 OP_Utils::evalOpParm(result, thissop,
"boundaryweight", cookparms.
getCookTime(), 0);
862 if (!thissop)
return getBoundaryRot();
864 OP_Utils::evalOpParm(result, thissop,
"boundaryRot", cookparms.
getCookTime(), 0);
872 if (!thissop)
return getGuideAttrib();
874 OP_Utils::evalOpParm(result, thissop,
"guideattrib", cookparms.
getCookTime(), 0);
882 if (!thissop)
return getFieldAttrib();
884 OP_Utils::evalOpParm(result, thissop,
"fieldattrib", cookparms.
getCookTime(), 0);
892 if (!thissop)
return getNormalizeField();
894 OP_Utils::evalOpParm(result, thissop,
"normalizefield", cookparms.
getCookTime(), 0);
902 if (!thissop)
return getOutputMode();
904 OP_Utils::evalOpParm(result, thissop,
"outputmode", cookparms.
getCookTime(), 0);
912 if (!thissop)
return getUseSingularGroup();
914 OP_Utils::evalOpParm(result, thissop,
"usesingulargroup", cookparms.
getCookTime(), 0);
922 if (!thissop)
return getSingularGroup();
924 OP_Utils::evalOpParm(result, thissop,
"singulargroup", cookparms.
getCookTime(), 0);
932 if (!thissop)
return getUsePositiveSingularGroup();
934 OP_Utils::evalOpParm(result, thissop,
"usepositivesingulargroup", cookparms.
getCookTime(), 0);
942 if (!thissop)
return getPositiveSingularGroup();
944 OP_Utils::evalOpParm(result, thissop,
"positivesingulargroup", cookparms.
getCookTime(), 0);
952 if (!thissop)
return getUseNegativeSingularGroup();
954 OP_Utils::evalOpParm(result, thissop,
"usenegativesingulargroup", cookparms.
getCookTime(), 0);
962 if (!thissop)
return getNegativeSingularGroup();
964 OP_Utils::evalOpParm(result, thissop,
"negativesingulargroup", cookparms.
getCookTime(), 0);
972 if (!thissop)
return getUseDiscontinuitiesGroup();
974 OP_Utils::evalOpParm(result, thissop,
"usediscontinuitiesgroup", cookparms.
getCookTime(), 0);
982 if (!thissop)
return getDiscontinuities();
984 OP_Utils::evalOpParm(result, thissop,
"discontinuities", cookparms.
getCookTime(), 0);
992 if (!thissop)
return getShowField();
994 OP_Utils::evalOpParm(result, thissop,
"showfield", cookparms.
getCookTime(), 0);
1002 if (!thissop)
return getShowNormalized();
1004 OP_Utils::evalOpParm(result, thissop,
"shownormalized", cookparms.
getCookTime(), 0);
1012 if (!thissop)
return getShowPrescaled();
1014 OP_Utils::evalOpParm(result, thissop,
"showprescaled", cookparms.
getCookTime(), 0);
1022 if (!thissop)
return getVectorscale();
1024 OP_Utils::evalOpParm(result, thissop,
"vectorscale", cookparms.
getCookTime(), 0);
1032 if (!thissop)
return getShowSingularities();
1034 OP_Utils::evalOpParm(result, thissop,
"showsingularities", cookparms.
getCookTime(), 0);
1042 if (!thissop)
return getGuideAttribWeight();
1044 OP_Utils::evalOpParm(result, thissop,
"guideattribweight", cookparms.
getCookTime(), 0);
1054 int64 myFlipCurvatureAxes;
1056 int64 myBoundaryRot;
1059 bool myNormalizeField;
1061 bool myUseSingularGroup;
1063 bool myUsePositiveSingularGroup;
1065 bool myUseNegativeSingularGroup;
1067 bool myUseDiscontinuitiesGroup;
1070 bool myShowNormalized;
1071 bool myShowPrescaled;
1073 bool myShowSingularities;
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2D &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void setShowNormalized(bool val)
bool load(UT_IStream &is)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
static void loadData(UT_IStream &is, fpreal64 &v)
void setCurvatureWeight(fpreal64 val)
SOP_Node * getNode() const
bool opShowField(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getGuideAttribWeight() const
const UT_StringHolder & getFieldAttrib() const
UT_StringHolder opFieldAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool opNormalizeField(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getNegativeSingularGroup() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
T clampMaxValue(fpreal maxvalue, const T &src) const
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
exint bread(int32 *buffer, exint asize=1)
void setShowPrescaled(bool val)
GT_API const UT_StringHolder time
constexpr SYS_FORCE_INLINE T & y() noexcept
bool operator==(const SOP_TangentFieldParms &src) const
bool getUsePositiveSingularGroup() const
bool opUseSingularGroup(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
static void loadData(UT_IStream &is, UT_Vector4I &v)
static void loadData(UT_IStream &is, int64 &v)
fpreal64 getCurvatureWeight() const
void setFieldAttrib(const UT_StringHolder &val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
fpreal64 opCurvatureWeight(const SOP_NodeVerb::CookParms &cookparms) const
const OP_Context & context() const
constexpr SYS_FORCE_INLINE T & z() noexcept
SYS_FORCE_INLINE const char * buffer() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
An output stream object that owns its own string buffer storage.
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
static void saveData(std::ostream &os, UT_Matrix3D v)
bool opShowPrescaled(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getGroup() const
void setShowField(bool val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
**But if you need a result
void setOutputMode(OutputMode val)
bool opShowSingularities(const SOP_NodeVerb::CookParms &cookparms) const
T clampMinValue(fpreal minvalue, const T &src) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
UT_StringHolder opDiscontinuities(const SOP_NodeVerb::CookParms &cookparms) const
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
static void saveData(std::ostream &os, UT_Matrix4D v)
FlipCurvatureAxes opFlipCurvatureAxes(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getBoundaryWeight() const
ParmType getNestParmType(TempIndex fieldnum) const override
constexpr SYS_FORCE_INLINE T & x() noexcept
void copyFrom(const OP_NodeParms *src) override
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
void setCarrier(Carrier val)
fpreal64 opBoundaryWeight(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opNegativeSingularGroup(const SOP_NodeVerb::CookParms &cookparms) const
BoundaryRot getBoundaryRot() const
static void loadData(UT_IStream &is, UT_Vector2I &v)
constexpr SYS_FORCE_INLINE T & x() noexcept
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
bool getShowSingularities() const
fpreal64 getVectorscale() const
void setBoundaryWeight(fpreal64 val)
bool getNormalizeField() const
bool getUseSingularGroup() const
void setUseDiscontinuitiesGroup(bool val)
static void saveData(std::ostream &os, UT_Vector4D v)
Carrier getCarrier() const
void setVectorscale(fpreal64 val)
static void saveData(std::ostream &os, bool v)
fpreal64 opGuideAttribWeight(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opPositiveSingularGroup(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getGuideAttrib() const
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
fpreal64 opVectorscale(const SOP_NodeVerb::CookParms &cookparms) const
void setGuideAttrib(const UT_StringHolder &val)
bool getUseDiscontinuitiesGroup() const
constexpr SYS_FORCE_INLINE T & z() noexcept
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
const OP_GraphProxy * graph() const
bool opUsePositiveSingularGroup(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
static void loadData(UT_IStream &is, UT_Vector3I &v)
static void saveData(std::ostream &os, UT_Vector2D v)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
static void saveData(std::ostream &os, int64 v)
bool isParmColorRamp(exint idx) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
void setShowSingularities(bool val)
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
void setNormalizeField(bool val)
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
void setRotation(fpreal64 val)
bool opUseDiscontinuitiesGroup(const SOP_NodeVerb::CookParms &cookparms) const
void saveBinary(std::ostream &os) const
Save string to binary stream.
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
void loadFromOpSubclass(const LoadParms &loadparms) override
const UT_StringHolder & getPositiveSingularGroup() const
GT_API const UT_StringHolder version
static void saveData(std::ostream &os, UT_Vector3D v)
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
OutputMode opOutputMode(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseNegativeSingularGroup() const
fpreal64 getRotation() const
bool opShowNormalized(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opGuideAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setGuideAttribWeight(fpreal64 val)
void setPositiveSingularGroup(const UT_StringHolder &val)
void coerceValue(T &result, const S &src) const
int64 getDirections() const
DEP_MicroNode * depnode() const
bool operator!=(const SOP_TangentFieldParms &src) const
fpreal64 opRotation(const SOP_NodeVerb::CookParms &cookparms) const
bool getShowField() const
Utility class for containing a color ramp.
constexpr SYS_FORCE_INLINE T & w() noexcept
UT_StringHolder opSingularGroup(const SOP_NodeVerb::CookParms &cookparms) const
void setUsePositiveSingularGroup(bool val)
bool getShowPrescaled() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
bool opUseNegativeSingularGroup(const SOP_NodeVerb::CookParms &cookparms) const
void setUseSingularGroup(bool val)
void setSingularGroup(const UT_StringHolder &val)
static void loadData(UT_IStream &is, UT_Vector3D &v)
fpreal getCookTime() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
void setNegativeSingularGroup(const UT_StringHolder &val)
static void saveData(std::ostream &os, fpreal64 v)
const char * getNestParmName(TempIndex fieldnum) const override
FlipCurvatureAxes getFlipCurvatureAxes() const
Carrier opCarrier(const SOP_NodeVerb::CookParms &cookparms) const
const char * findChar(int c) const
static void loadData(UT_IStream &is, bool &v)
void setDiscontinuities(const UT_StringHolder &val)
void setUseNegativeSingularGroup(bool val)
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
void save(std::ostream &os) const
exint getNestNumParms(TempIndex idx) const override
int64 opDirections(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_StringHolder &v)
BoundaryRot opBoundaryRot(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & y() noexcept
OutputMode getOutputMode() const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
void setFlipCurvatureAxes(FlipCurvatureAxes val)
static void loadData(UT_IStream &is, UT_Vector4D &v)
const UT_StringHolder & getSingularGroup() const
static void saveData(std::ostream &os, UT_StringHolder s)
void setBoundaryRot(BoundaryRot val)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
constexpr SYS_FORCE_INLINE T & y() noexcept
bool getShowNormalized() const
void setGroup(const UT_StringHolder &val)
SYS_FORCE_INLINE bool isstring() const
void setDirections(int64 val)
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
OP_NodeParms & operator=(const OP_NodeParms &)=default
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
static void saveData(std::ostream &os, UT_Matrix2D v)
const UT_StringHolder & getDiscontinuities() const
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
constexpr SYS_FORCE_INLINE T & x() noexcept