23 namespace SOP_MLExampleDeserializePackedEnums
34 using namespace UT::Literal;
51 using namespace UT::Literal;
78 inputpointattribute =
"value"_UTsh;
79 inputvolumename =
"density"_UTsh;
87 if (inputtype != src.
inputtype)
return false;
107 for (
int i = 0; i < list.
entries(); i++)
142 targetpointattribute =
"value"_UTsh;
143 targetvolumename =
"density"_UTsh;
151 if (targettype != src.
targettype)
return false;
171 for (
int i = 0; i < list.
entries(); i++)
197 myInputDimensionAttribute =
"inputdimension"_UTsh;
198 myTargetDimensionAttribute =
"targetdimension"_UTsh;
199 mySerialAttribute =
"value"_UTsh;
201 myTargets.setSize(1);
214 if (myInputDimensionAttribute != src.myInputDimensionAttribute)
return false;
215 if (myTargetDimensionAttribute != src.myTargetDimensionAttribute)
return false;
216 if (mySerialAttribute != src.mySerialAttribute)
return false;
217 if (myInputs != src.myInputs)
return false;
218 if (myTargets != src.myTargets)
return false;
236 myInputDimensionAttribute =
"inputdimension"_UTsh;
238 graph->
evalOpParm(myInputDimensionAttribute, nodeidx,
"inputdimensionattribute", time, graph->
isDirect()?
nullptr:depnode);
239 myTargetDimensionAttribute =
"targetdimension"_UTsh;
241 graph->
evalOpParm(myTargetDimensionAttribute, nodeidx,
"targetdimensionattribute", time, graph->
isDirect()?
nullptr:depnode);
242 mySerialAttribute =
"value"_UTsh;
244 graph->
evalOpParm(mySerialAttribute, nodeidx,
"serialattribute", time, graph->
isDirect()?
nullptr:depnode);
248 graph->
evalOpParm(length, nodeidx,
"inputs", time, graph->
isDirect()?
nullptr:depnode);
249 if (length < 0) length = 0;
250 myInputs.setSize(length);
257 auto && _curentry = myInputs(i);
259 _curentry.inputtype = 0;
261 graph->
evalOpParmInst(_curentry.inputtype, nodeidx,
"inputtype#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
262 _curentry.inputpointattribute =
"value"_UTsh;
263 if (
true && ( (
true&&!(((_curentry.inputtype!=0)))) ) )
264 graph->
evalOpParmInst(_curentry.inputpointattribute, nodeidx,
"inputpointattribute#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
265 _curentry.inputvolumename =
"density"_UTsh;
266 if (
true && ( (
true&&!(((_curentry.inputtype!=1)))) ) )
267 graph->
evalOpParmInst(_curentry.inputvolumename, nodeidx,
"inputvolumename#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
268 _curentry.inputvolumeresolution =
UT_Vector3I(10,10,10);
269 if (
true && ( (
true&&!(((_curentry.inputtype!=1)))) ) )
270 graph->
evalOpParmInst(_curentry.inputvolumeresolution, nodeidx,
"inputvolumeresolution#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
271 _curentry.inputtuplesize = 1;
273 graph->
evalOpParmInst(_curentry.inputtuplesize, nodeidx,
"inputtuplesize#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
282 graph->
evalOpParm(length, nodeidx,
"targets", time, graph->
isDirect()?
nullptr:depnode);
283 if (length < 0) length = 0;
284 myTargets.setSize(length);
291 auto && _curentry = myTargets(i);
293 _curentry.targettype = 0;
295 graph->
evalOpParmInst(_curentry.targettype, nodeidx,
"targettype#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
296 _curentry.targetpointattribute =
"value"_UTsh;
297 if (
true && ( (
true&&!(((_curentry.targettype!=0)))) ) )
298 graph->
evalOpParmInst(_curentry.targetpointattribute, nodeidx,
"targetpointattribute#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
299 _curentry.targetvolumename =
"density"_UTsh;
300 if (
true && ( (
true&&!(((_curentry.targettype!=1)))) ) )
301 graph->
evalOpParmInst(_curentry.targetvolumename, nodeidx,
"targetvolumename#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
302 _curentry.targetvolumeresolution =
UT_Vector3I(10,10,10);
303 if (
true && ( (
true&&!(((_curentry.targettype!=1)))) ) )
304 graph->
evalOpParmInst(_curentry.targetvolumeresolution, nodeidx,
"targetvolumeresolution#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
305 _curentry.targettuplesize = 1;
307 graph->
evalOpParmInst(_curentry.targettuplesize, nodeidx,
"targettuplesize#", parmidx, offsets, time, graph->
isDirect()?
nullptr:depnode, 2-1);
328 template <
typename T>
335 if (idx.
size() != instance.
size()+1)
340 coerceValue(value, myInputDimensionAttribute);
343 coerceValue(value, myTargetDimensionAttribute);
346 coerceValue(value, mySerialAttribute);
350 coerceValue(value, myInputs.entries());
351 else if (instance[0] < myInputs.entries())
353 auto && _data = myInputs(instance[0]);
357 coerceValue(value, _data.inputtype);
360 coerceValue(value, _data.inputpointattribute);
363 coerceValue(value, _data.inputvolumename);
366 coerceValue(value, _data.inputvolumeresolution);
369 coerceValue(value, _data.inputtuplesize);
377 coerceValue(value, myTargets.entries());
378 else if (instance[0] < myTargets.entries())
380 auto && _data = myTargets(instance[0]);
384 coerceValue(value, _data.targettype);
387 coerceValue(value, _data.targetpointattribute);
390 coerceValue(value, _data.targetvolumename);
393 coerceValue(value, _data.targetvolumeresolution);
396 coerceValue(value, _data.targettuplesize);
416 { doGetParmValue(idx, instance, value); }
418 { doGetParmValue(idx, instance, value); }
420 { doGetParmValue(idx, instance, value); }
422 { doGetParmValue(idx, instance, value); }
424 { doGetParmValue(idx, instance, value); }
426 { doGetParmValue(idx, instance, value); }
428 { doGetParmValue(idx, instance, value); }
430 { doGetParmValue(idx, instance, value); }
432 { doGetParmValue(idx, instance, value); }
434 { doGetParmValue(idx, instance, value); }
436 { doGetParmValue(idx, instance, value); }
438 template <
typename T>
445 if (idx.
size() != instance.
size()+1)
450 coerceValue(myInputDimensionAttribute, ( ( value ) ));
453 coerceValue(myTargetDimensionAttribute, ( ( value ) ));
456 coerceValue(mySerialAttribute, ( ( value ) ));
462 coerceValue(newsize, value);
463 if (newsize < 0) newsize = 0;
464 myInputs.setSize(newsize);
470 myInputs.setSizeIfNeeded(instance[0]+1);
471 auto && _data = myInputs(instance[0]);
475 coerceValue(_data.inputtype, value);
478 coerceValue(_data.inputpointattribute, value);
481 coerceValue(_data.inputvolumename, value);
484 coerceValue(_data.inputvolumeresolution, value);
487 coerceValue(_data.inputtuplesize, value);
497 coerceValue(newsize, value);
498 if (newsize < 0) newsize = 0;
499 myTargets.setSize(newsize);
505 myTargets.setSizeIfNeeded(instance[0]+1);
506 auto && _data = myTargets(instance[0]);
510 coerceValue(_data.targettype, value);
513 coerceValue(_data.targetpointattribute, value);
516 coerceValue(_data.targetvolumename, value);
519 coerceValue(_data.targetvolumeresolution, value);
522 coerceValue(_data.targettuplesize, value);
533 { doSetParmValue(idx, instance, value); }
535 { doSetParmValue(idx, instance, value); }
537 { doSetParmValue(idx, instance, value); }
539 { doSetParmValue(idx, instance, value); }
541 { doSetParmValue(idx, instance, value); }
543 { doSetParmValue(idx, instance, value); }
545 { doSetParmValue(idx, instance, value); }
547 { doSetParmValue(idx, instance, value); }
549 { doSetParmValue(idx, instance, value); }
551 { doSetParmValue(idx, instance, value); }
553 { doSetParmValue(idx, instance, value); }
573 if (fieldnum.
size() < 1)
578 return "inputdimensionattribute";
580 return "targetdimensionattribute";
582 return "serialattribute";
584 if (fieldnum.
size() == 1)
591 return "inputpointattribute#";
593 return "inputvolumename#";
595 return "inputvolumeresolution#";
597 return "inputtuplesize#";
602 if (fieldnum.
size() == 1)
607 return "targettype#";
609 return "targetpointattribute#";
611 return "targetvolumename#";
613 return "targetvolumeresolution#";
615 return "targettuplesize#";
626 if (fieldnum.
size() < 1)
627 return PARM_UNSUPPORTED;
637 if (fieldnum.
size() == 1)
638 return PARM_MULTIPARM;
653 return PARM_UNSUPPORTED;
655 if (fieldnum.
size() == 1)
656 return PARM_MULTIPARM;
671 return PARM_UNSUPPORTED;
674 return PARM_UNSUPPORTED;
710 loadData(is, rampdata);
728 int typelen = colon - data.
buffer();
742 {
int64 iv =
v; UTwrite(os, &iv); }
744 { UTwrite<fpreal64>(os, &
v); }
746 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
748 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
749 UTwrite<fpreal64>(os, &v.
z()); }
751 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
752 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
764 if (s) s->save(ostr);
766 saveData(os, result);
773 ostr << s->getDataTypeToken();
778 saveData(os, result);
782 void save(std::ostream &os)
const
786 saveData(os, myInputDimensionAttribute);
787 saveData(os, myTargetDimensionAttribute);
788 saveData(os, mySerialAttribute);
791 UTwrite(os, &length);
794 auto && _curentry = myInputs(i);
796 saveData(os, _curentry.inputtype);
797 saveData(os, _curentry.inputpointattribute);
798 saveData(os, _curentry.inputvolumename);
799 saveData(os, _curentry.inputvolumeresolution);
800 saveData(os, _curentry.inputtuplesize);
806 UTwrite(os, &length);
809 auto && _curentry = myTargets(i);
811 saveData(os, _curentry.targettype);
812 saveData(os, _curentry.targetpointattribute);
813 saveData(os, _curentry.targetvolumename);
814 saveData(os, _curentry.targetvolumeresolution);
815 saveData(os, _curentry.targettuplesize);
831 loadData(is, myInputDimensionAttribute);
832 loadData(is, myTargetDimensionAttribute);
833 loadData(is, mySerialAttribute);
837 myInputs.setSize(length);
840 auto && _curentry = myInputs(i);
842 loadData(is, _curentry.inputtype);
843 loadData(is, _curentry.inputpointattribute);
844 loadData(is, _curentry.inputvolumename);
845 loadData(is, _curentry.inputvolumeresolution);
846 loadData(is, _curentry.inputtuplesize);
853 myTargets.setSize(length);
856 auto && _curentry = myTargets(i);
858 loadData(is, _curentry.targettype);
859 loadData(is, _curentry.targetpointattribute);
860 loadData(is, _curentry.targetvolumename);
861 loadData(is, _curentry.targetvolumeresolution);
862 loadData(is, _curentry.targettuplesize);
875 if (!thissop)
return getInputDimensionAttribute();
877 OP_Utils::evalOpParm(result, thissop,
"inputdimensionattribute", cookparms.
getCookTime(), 0);
885 if (!thissop)
return getTargetDimensionAttribute();
887 OP_Utils::evalOpParm(result, thissop,
"targetdimensionattribute", cookparms.
getCookTime(), 0);
895 if (!thissop)
return getSerialAttribute();
897 OP_Utils::evalOpParm(result, thissop,
"serialattribute", cookparms.
getCookTime(), 0);
905 if (!thissop)
return getInputs().entries();
907 OP_Utils::evalOpParm(result, thissop,
"inputs", cookparms.
getCookTime(), 0);
911 {
return opinstInputs_inputtype(cookparms, &_idx); }
915 if (!thissop)
return (myInputs(_idx[0]).inputtype);
917 _parmidx[1-1] = _idx[1-1] + 1;
920 OP_Utils::evalOpParmInst(result, thissop,
"inputtype#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
924 {
return opinstInputs_inputpointattribute(cookparms, &_idx); }
928 if (!thissop)
return (myInputs(_idx[0]).inputpointattribute);
930 _parmidx[1-1] = _idx[1-1] + 1;
933 OP_Utils::evalOpParmInst(result, thissop,
"inputpointattribute#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
937 {
return opinstInputs_inputvolumename(cookparms, &_idx); }
941 if (!thissop)
return (myInputs(_idx[0]).inputvolumename);
943 _parmidx[1-1] = _idx[1-1] + 1;
946 OP_Utils::evalOpParmInst(result, thissop,
"inputvolumename#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
950 {
return opinstInputs_inputvolumeresolution(cookparms, &_idx); }
954 if (!thissop)
return (myInputs(_idx[0]).inputvolumeresolution);
956 _parmidx[1-1] = _idx[1-1] + 1;
959 OP_Utils::evalOpParmInst(result, thissop,
"inputvolumeresolution#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
963 {
return opinstInputs_inputtuplesize(cookparms, &_idx); }
967 if (!thissop)
return (myInputs(_idx[0]).inputtuplesize);
969 _parmidx[1-1] = _idx[1-1] + 1;
972 OP_Utils::evalOpParmInst(result, thissop,
"inputtuplesize#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
981 if (!thissop)
return getTargets().entries();
983 OP_Utils::evalOpParm(result, thissop,
"targets", cookparms.
getCookTime(), 0);
987 {
return opinstTargets_targettype(cookparms, &_idx); }
991 if (!thissop)
return (myTargets(_idx[0]).targettype);
993 _parmidx[1-1] = _idx[1-1] + 1;
996 OP_Utils::evalOpParmInst(result, thissop,
"targettype#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
1000 {
return opinstTargets_targetpointattribute(cookparms, &_idx); }
1004 if (!thissop)
return (myTargets(_idx[0]).targetpointattribute);
1006 _parmidx[1-1] = _idx[1-1] + 1;
1009 OP_Utils::evalOpParmInst(result, thissop,
"targetpointattribute#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
1013 {
return opinstTargets_targetvolumename(cookparms, &_idx); }
1017 if (!thissop)
return (myTargets(_idx[0]).targetvolumename);
1019 _parmidx[1-1] = _idx[1-1] + 1;
1022 OP_Utils::evalOpParmInst(result, thissop,
"targetvolumename#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
1026 {
return opinstTargets_targetvolumeresolution(cookparms, &_idx); }
1030 if (!thissop)
return (myTargets(_idx[0]).targetvolumeresolution);
1032 _parmidx[1-1] = _idx[1-1] + 1;
1035 OP_Utils::evalOpParmInst(result, thissop,
"targetvolumeresolution#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
1039 {
return opinstTargets_targettuplesize(cookparms, &_idx); }
1043 if (!thissop)
return (myTargets(_idx[0]).targettuplesize);
1045 _parmidx[1-1] = _idx[1-1] + 1;
1048 OP_Utils::evalOpParmInst(result, thissop,
"targettuplesize#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
UT_Vector3I opinstInputs_inputvolumeresolution(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
UT_StringHolder opinstTargets_targetvolumename(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
static void saveData(std::ostream &os, UT_Matrix4D v)
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
GLenum GLuint GLenum GLsizei const GLchar * buf
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
SOP_Node * getNode() const
int64 opinstTargets_targettype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
int64 opInputs_inputtuplesize(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
UT_StringHolder opSerialAttribute(const SOP_NodeVerb::CookParms &cookparms) const
int64 opinstTargets_targettuplesize(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
exint bread(int32 *buffer, exint asize=1)
exint opInputs(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const SOP_MLExampleDeserializePackedParms &src) const
GT_API const UT_StringHolder time
constexpr SYS_FORCE_INLINE T & y() noexcept
void save(std::ostream &os) const
GLsizei const GLfloat * value
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
void loadFromOpSubclass(const LoadParms &loadparms) override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
void setTargetDimensionAttribute(const UT_StringHolder &val)
bool operator==(const Targets &src) const
UT_String makeQuotedString(char delimiter='\'', bool escape_nonprinting=false) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
const OP_Context & context() const
static void loadData(UT_IStream &is, bool &v)
constexpr SYS_FORCE_INLINE T & z() noexcept
UT_Vector3I opTargets_targetvolumeresolution(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
SYS_FORCE_INLINE const char * buffer() const
void setInputs(const UT_Array< Inputs > &val)
exint opTargets(const SOP_NodeVerb::CookParms &cookparms) const
GLuint GLsizei GLsizei * length
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
An output stream object that owns its own string buffer storage.
static void saveData(std::ostream &os, UT_Matrix3D v)
UT_StringHolder opTargets_targetpointattribute(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
int64 opTargets_targettuplesize(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
**But if you need a result
UT_Vector3T< int64 > UT_Vector3I
UT_StringHolder opTargetDimensionAttribute(const SOP_NodeVerb::CookParms &cookparms) 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.
bool operator!=(const Targets &src) const
constexpr SYS_FORCE_INLINE T & x() noexcept
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
int64 opinstInputs_inputtype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
GLuint GLsizei const GLuint const GLintptr * offsets
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
int64 opInputs_inputtype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
constexpr SYS_FORCE_INLINE T & x() noexcept
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
UT_StringHolder opinstTargets_targetpointattribute(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
UT_StringHolder opInputs_inputpointattribute(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
void setInputDimensionAttribute(const UT_StringHolder &val)
static void loadData(UT_IStream &is, UT_Vector4I &v)
UT_StringHolder opinstInputs_inputvolumename(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
static void saveData(std::ostream &os, UT_Vector4D v)
ParmType getNestParmType(TempIndex fieldnum) const override
exint getNestNumParms(TempIndex idx) const override
int64 opinstInputs_inputtuplesize(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
static void saveData(std::ostream &os, fpreal64 v)
UT_StringHolder createString(const UT_Array< Targets > &list) const
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
const UT_Array< Inputs > & getInputs() const
constexpr SYS_FORCE_INLINE T & z() noexcept
exint read(bool *array, exint sz=1)
const OP_GraphProxy * graph() const
static void loadData(UT_IStream &is, int64 &v)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
bool operator!=(const SOP_MLExampleDeserializePackedParms &src) const
virtual void evalOpParmInst(int64 &v, NodeIdx node, const char *parmname, const int *inst, const int *offsets, fpreal time, DEP_MicroNode *depnode, int nestlevel=1) const =0
const UT_StringHolder & getSerialAttribute() const
const UT_StringHolder & getTargetDimensionAttribute() const
UT_StringHolder createString(const UT_Array< Inputs > &list) const
UT_StringHolder targetvolumename
SYS_FORCE_INLINE UT_StringHolder getToken(InputType enum_value)
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
UT_Vector3I targetvolumeresolution
static void saveData(std::ostream &os, PRM_DataItemHandle s)
SYS_FORCE_INLINE void strcat(const char *src)
void saveBinary(std::ostream &os) const
Save string to binary stream.
GT_API const UT_StringHolder version
int64 opTargets_targettype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
exint entries() const
Alias of size(). size() is preferred.
SOP_MLExampleDeserializePackedParms()
void setSerialAttribute(const UT_StringHolder &val)
static void loadData(UT_IStream &is, fpreal64 &v)
UT_Vector3I opinstTargets_targetvolumeresolution(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
static void loadData(UT_IStream &is, UT_Vector2I &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
int int appendSprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
static void saveData(std::ostream &os, UT_Matrix2D v)
static void loadData(UT_IStream &is, UT_Vector3D &v)
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
UT_StringHolder opInputs_inputvolumename(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
bool load(UT_IStream &is)
DEP_MicroNode * depnode() const
UT_StringHolder opInputDimensionAttribute(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargets_targetvolumename(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
LeafData & operator=(const LeafData &)=delete
Utility class for containing a color ramp.
static void saveData(std::ostream &os, UT_Vector3D v)
static void loadData(UT_IStream &is, UT_Vector3I &v)
constexpr SYS_FORCE_INLINE T & w() noexcept
SYS_FORCE_INLINE void append(char character)
UT_StringHolder opinstInputs_inputpointattribute(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
static void saveData(std::ostream &os, UT_StringHolder s)
bool isParmColorRamp(exint idx) const override
virtual UT_StringHolder baseGetSignature() const
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
UT_Vector3I opInputs_inputvolumeresolution(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
static void saveData(std::ostream &os, bool v)
fpreal getCookTime() const
static void loadData(UT_IStream &is, UT_Vector2D &v)
const char * findChar(int c) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
static void saveData(std::ostream &os, int64 v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
void copyFrom(const OP_NodeParms *src) override
static void loadData(UT_IStream &is, UT_Matrix3D &v)
const UT_Array< Targets > & getTargets() const
constexpr SYS_FORCE_INLINE T & y() noexcept
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
UT_StringHolder targetpointattribute
const UT_StringHolder & getInputDimensionAttribute() const
virtual bool isDirect() const =0
Direct proxies mirror actual nodes:
void setTargets(const UT_Array< Targets > &val)
const char * getNestParmName(TempIndex fieldnum) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
static void loadData(UT_IStream &is, UT_Vector4D &v)
constexpr SYS_FORCE_INLINE T & y() noexcept
SYS_FORCE_INLINE bool isstring() const
static void saveData(std::ostream &os, UT_Vector2D v)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
static void loadData(UT_IStream &is, UT_StringHolder &v)
constexpr SYS_FORCE_INLINE T & x() noexcept