HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_MLExampleDeserializePacked.proto.h
Go to the documentation of this file.
1 /* Automagically Generated by generate_proto.py
2  * Do not Edit
3  */
4 #pragma once
5 
6 #include <SOP/SOP_API.h>
7 #include <SOP/SOP_NodeVerb.h>
8 #include <OP/OP_GraphProxy.h>
9 
10 #include <OP/OP_Utils.h>
11 #include <PRM/PRM_Parm.h>
12 #include <UT/UT_IStream.h>
13 #include <UT/UT_NTStreamUtil.h>
14 #include <UT/UT_Ramp.h>
15 #include <UT/UT_SharedPtr.h>
16 #include <UT/UT_StringHolder.h>
17 #include <UT/UT_StringStream.h>
18 #include <UT/UT_VectorTypes.h>
19 #include <UT/UT_EnvControl.h>
20 #include <SYS/SYS_Types.h>
21 
22 class DEP_MicroNode;
23 namespace SOP_MLExampleDeserializePackedEnums
24 {
25  enum class InputType
26  {
27  POINT = 0,
28  VOLUME
29  };
30 
32  getToken(InputType enum_value)
33  {
34  using namespace UT::Literal;
35  switch (enum_value) {
36  case InputType::POINT: return "point"_sh;
37  case InputType::VOLUME: return "volume"_sh;
38  default: UT_ASSERT(false); return ""_sh;
39  }
40  }
41 
42  enum class TargetType
43  {
44  POINT = 0,
45  VOLUME
46  };
47 
49  getToken(TargetType enum_value)
50  {
51  using namespace UT::Literal;
52  switch (enum_value) {
53  case TargetType::POINT: return "point"_sh;
54  case TargetType::VOLUME: return "volume"_sh;
55  default: UT_ASSERT(false); return ""_sh;
56  }
57  }
58 
59 }
60 
61 
63 {
64 public:
65  static int version() { return 1; }
66  struct Inputs
67  {
73 
74 
76  {
77  inputtype = 0;
78  inputpointattribute = "value"_UTsh;
79  inputvolumename = "density"_UTsh;
80  inputvolumeresolution = UT_Vector3I(10,10,10);
81  inputtuplesize = 1;
82 
83  }
84 
85  bool operator==(const Inputs &src) const
86  {
87  if (inputtype != src.inputtype) return false;
88  if (inputpointattribute != src.inputpointattribute) return false;
89  if (inputvolumename != src.inputvolumename) return false;
90  if (inputvolumeresolution != src.inputvolumeresolution) return false;
91  if (inputtuplesize != src.inputtuplesize) return false;
92 
93  return true;
94  }
95  bool operator!=(const Inputs &src) const
96  {
97  return !operator==(src);
98  }
99 
100  };
101 
103  {
105 
106  buf.strcat("[ ");
107  for (int i = 0; i < list.entries(); i++)
108  {
109  if (i)
110  buf.strcat(", ");
111  buf.strcat("( ");
112  buf.append("");
113  buf.appendSprintf("%d", (int) list(i).inputtype);
114  buf.append(", ");
115  { UT_String tmp; tmp = UT_StringWrap(list(i).inputpointattribute).makeQuotedString('"'); buf.strcat(tmp); }
116  buf.append(", ");
117  { UT_String tmp; tmp = UT_StringWrap(list(i).inputvolumename).makeQuotedString('"'); buf.strcat(tmp); }
118  buf.append(", ");
119  buf.appendSprintf("(%" SYS_PRId64 ", %" SYS_PRId64 ", %" SYS_PRId64 ")", list(i).inputvolumeresolution.x(), list(i).inputvolumeresolution.y(), list(i).inputvolumeresolution.z());
120  buf.append(", ");
121  buf.appendSprintf("%d", (int) list(i).inputtuplesize);
122 
123  buf.strcat(" )");
124  }
125  buf.strcat(" ]");
126 
128  return result;
129  }
130  struct Targets
131  {
137 
138 
140  {
141  targettype = 0;
142  targetpointattribute = "value"_UTsh;
143  targetvolumename = "density"_UTsh;
144  targetvolumeresolution = UT_Vector3I(10,10,10);
145  targettuplesize = 1;
146 
147  }
148 
149  bool operator==(const Targets &src) const
150  {
151  if (targettype != src.targettype) return false;
152  if (targetpointattribute != src.targetpointattribute) return false;
153  if (targetvolumename != src.targetvolumename) return false;
154  if (targetvolumeresolution != src.targetvolumeresolution) return false;
155  if (targettuplesize != src.targettuplesize) return false;
156 
157  return true;
158  }
159  bool operator!=(const Targets &src) const
160  {
161  return !operator==(src);
162  }
163 
164  };
165 
167  {
169 
170  buf.strcat("[ ");
171  for (int i = 0; i < list.entries(); i++)
172  {
173  if (i)
174  buf.strcat(", ");
175  buf.strcat("( ");
176  buf.append("");
177  buf.appendSprintf("%d", (int) list(i).targettype);
178  buf.append(", ");
179  { UT_String tmp; tmp = UT_StringWrap(list(i).targetpointattribute).makeQuotedString('"'); buf.strcat(tmp); }
180  buf.append(", ");
181  { UT_String tmp; tmp = UT_StringWrap(list(i).targetvolumename).makeQuotedString('"'); buf.strcat(tmp); }
182  buf.append(", ");
183  buf.appendSprintf("(%" SYS_PRId64 ", %" SYS_PRId64 ", %" SYS_PRId64 ")", list(i).targetvolumeresolution.x(), list(i).targetvolumeresolution.y(), list(i).targetvolumeresolution.z());
184  buf.append(", ");
185  buf.appendSprintf("%d", (int) list(i).targettuplesize);
186 
187  buf.strcat(" )");
188  }
189  buf.strcat(" ]");
190 
192  return result;
193  }
194 
196  {
197  myInputDimensionAttribute = "inputdimension"_UTsh;
198  myTargetDimensionAttribute = "targetdimension"_UTsh;
199  mySerialAttribute = "value"_UTsh;
200  myInputs.setSize(1);
201  myTargets.setSize(1);
202 
203  }
204 
209 
211 
213  {
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;
219 
220 
221  if (baseGetSignature() != src.baseGetSignature()) return false;
222 
223  return true;
224  }
226  {
227  return !operator==(src);
228  }
231 
232 
233 
234  void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
235  {
236  myInputDimensionAttribute = "inputdimension"_UTsh;
237  if (true)
238  graph->evalOpParm(myInputDimensionAttribute, nodeidx, "inputdimensionattribute", time, graph->isDirect()?nullptr:depnode);
239  myTargetDimensionAttribute = "targetdimension"_UTsh;
240  if (true)
241  graph->evalOpParm(myTargetDimensionAttribute, nodeidx, "targetdimensionattribute", time, graph->isDirect()?nullptr:depnode);
242  mySerialAttribute = "value"_UTsh;
243  if (true)
244  graph->evalOpParm(mySerialAttribute, nodeidx, "serialattribute", time, graph->isDirect()?nullptr:depnode);
245  if (true)
246  {
247  int64 length = 0;
248  graph->evalOpParm(length, nodeidx, "inputs", time, graph->isDirect()?nullptr:depnode);
249  if (length < 0) length = 0;
250  myInputs.setSize(length);
251  for (exint i = 0; i < length; i++)
252  {
253  int parmidx[1];
254  int offsets[1];
255  parmidx[0] = i+1;
256  offsets[0] = 1;
257  auto && _curentry = myInputs(i);
258  (void) _curentry;
259  _curentry.inputtype = 0;
260  if (true)
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;
272  if (true)
273  graph->evalOpParmInst(_curentry.inputtuplesize, nodeidx, "inputtuplesize#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
274 
275  }
276  }
277  else
278  myInputs.clear();
279  if (true)
280  {
281  int64 length = 0;
282  graph->evalOpParm(length, nodeidx, "targets", time, graph->isDirect()?nullptr:depnode);
283  if (length < 0) length = 0;
284  myTargets.setSize(length);
285  for (exint i = 0; i < length; i++)
286  {
287  int parmidx[1];
288  int offsets[1];
289  parmidx[0] = i+1;
290  offsets[0] = 1;
291  auto && _curentry = myTargets(i);
292  (void) _curentry;
293  _curentry.targettype = 0;
294  if (true)
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;
306  if (true)
307  graph->evalOpParmInst(_curentry.targettuplesize, nodeidx, "targettuplesize#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
308 
309  }
310  }
311  else
312  myTargets.clear();
313 
314  }
315 
316 
317  void loadFromOpSubclass(const LoadParms &loadparms) override
318  {
319  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
320  }
321 
322 
323  void copyFrom(const OP_NodeParms *src) override
324  {
325  *this = *((const SOP_MLExampleDeserializePackedParms *)src);
326  }
327 
328  template <typename T>
329  void
330  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
331  {
332  if (idx.size() < 1)
333  return;
334  UT_ASSERT(idx.size() == instance.size()+1);
335  if (idx.size() != instance.size()+1)
336  return;
337  switch (idx[0])
338  {
339  case 0:
340  coerceValue(value, myInputDimensionAttribute);
341  break;
342  case 1:
343  coerceValue(value, myTargetDimensionAttribute);
344  break;
345  case 2:
346  coerceValue(value, mySerialAttribute);
347  break;
348  case 3:
349  if (idx.size() == 1)
350  coerceValue(value, myInputs.entries());
351  else if (instance[0] < myInputs.entries())
352  {
353  auto && _data = myInputs(instance[0]);
354  switch (idx[1])
355  {
356  case 0:
357  coerceValue(value, _data.inputtype);
358  break;
359  case 1:
360  coerceValue(value, _data.inputpointattribute);
361  break;
362  case 2:
363  coerceValue(value, _data.inputvolumename);
364  break;
365  case 3:
366  coerceValue(value, _data.inputvolumeresolution);
367  break;
368  case 4:
369  coerceValue(value, _data.inputtuplesize);
370  break;
371 
372  }
373  }
374  break;
375  case 4:
376  if (idx.size() == 1)
377  coerceValue(value, myTargets.entries());
378  else if (instance[0] < myTargets.entries())
379  {
380  auto && _data = myTargets(instance[0]);
381  switch (idx[1])
382  {
383  case 0:
384  coerceValue(value, _data.targettype);
385  break;
386  case 1:
387  coerceValue(value, _data.targetpointattribute);
388  break;
389  case 2:
390  coerceValue(value, _data.targetvolumename);
391  break;
392  case 3:
393  coerceValue(value, _data.targetvolumeresolution);
394  break;
395  case 4:
396  coerceValue(value, _data.targettuplesize);
397  break;
398 
399  }
400  }
401  break;
402 
403  }
404  }
405 
406  bool isParmColorRamp(exint idx) const override
407  {
408  switch (idx)
409  {
410 
411  }
412  return false;
413  }
414 
415  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
416  { doGetParmValue(idx, instance, value); }
417  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
418  { doGetParmValue(idx, instance, value); }
419  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
420  { doGetParmValue(idx, instance, value); }
421  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
422  { doGetParmValue(idx, instance, value); }
423  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
424  { doGetParmValue(idx, instance, value); }
425  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
426  { doGetParmValue(idx, instance, value); }
427  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
428  { doGetParmValue(idx, instance, value); }
429  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
430  { doGetParmValue(idx, instance, value); }
431  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
432  { doGetParmValue(idx, instance, value); }
433  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
434  { doGetParmValue(idx, instance, value); }
435  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
436  { doGetParmValue(idx, instance, value); }
437 
438  template <typename T>
439  void
440  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
441  {
442  if (idx.size() < 1)
443  return;
444  UT_ASSERT(idx.size() == instance.size()+1);
445  if (idx.size() != instance.size()+1)
446  return;
447  switch (idx[0])
448  {
449  case 0:
450  coerceValue(myInputDimensionAttribute, ( ( value ) ));
451  break;
452  case 1:
453  coerceValue(myTargetDimensionAttribute, ( ( value ) ));
454  break;
455  case 2:
456  coerceValue(mySerialAttribute, ( ( value ) ));
457  break;
458  case 3:
459  if (idx.size() == 1)
460  {
461  exint newsize;
462  coerceValue(newsize, value);
463  if (newsize < 0) newsize = 0;
464  myInputs.setSize(newsize);
465  }
466  else
467  {
468  if (instance[0] < 0)
469  return;
470  myInputs.setSizeIfNeeded(instance[0]+1);
471  auto && _data = myInputs(instance[0]);
472  switch (idx[1])
473  {
474  case 0:
475  coerceValue(_data.inputtype, value);
476  break;
477  case 1:
478  coerceValue(_data.inputpointattribute, value);
479  break;
480  case 2:
481  coerceValue(_data.inputvolumename, value);
482  break;
483  case 3:
484  coerceValue(_data.inputvolumeresolution, value);
485  break;
486  case 4:
487  coerceValue(_data.inputtuplesize, value);
488  break;
489 
490  }
491  }
492  break;
493  case 4:
494  if (idx.size() == 1)
495  {
496  exint newsize;
497  coerceValue(newsize, value);
498  if (newsize < 0) newsize = 0;
499  myTargets.setSize(newsize);
500  }
501  else
502  {
503  if (instance[0] < 0)
504  return;
505  myTargets.setSizeIfNeeded(instance[0]+1);
506  auto && _data = myTargets(instance[0]);
507  switch (idx[1])
508  {
509  case 0:
510  coerceValue(_data.targettype, value);
511  break;
512  case 1:
513  coerceValue(_data.targetpointattribute, value);
514  break;
515  case 2:
516  coerceValue(_data.targetvolumename, value);
517  break;
518  case 3:
519  coerceValue(_data.targetvolumeresolution, value);
520  break;
521  case 4:
522  coerceValue(_data.targettuplesize, value);
523  break;
524 
525  }
526  }
527  break;
528 
529  }
530  }
531 
532  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
533  { doSetParmValue(idx, instance, value); }
534  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
535  { doSetParmValue(idx, instance, value); }
536  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
537  { doSetParmValue(idx, instance, value); }
538  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
539  { doSetParmValue(idx, instance, value); }
540  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
541  { doSetParmValue(idx, instance, value); }
542  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
543  { doSetParmValue(idx, instance, value); }
544  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
545  { doSetParmValue(idx, instance, value); }
546  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
547  { doSetParmValue(idx, instance, value); }
548  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
549  { doSetParmValue(idx, instance, value); }
550  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
551  { doSetParmValue(idx, instance, value); }
552  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
553  { doSetParmValue(idx, instance, value); }
554 
555  exint getNestNumParms(TempIndex idx) const override
556  {
557  if (idx.size() == 0)
558  return 5;
559  switch (idx[0])
560  {
561  case 3:
562  return 5;
563  case 4:
564  return 5;
565 
566  }
567  // Invalid
568  return 0;
569  }
570 
571  const char *getNestParmName(TempIndex fieldnum) const override
572  {
573  if (fieldnum.size() < 1)
574  return 0;
575  switch (fieldnum[0])
576  {
577  case 0:
578  return "inputdimensionattribute";
579  case 1:
580  return "targetdimensionattribute";
581  case 2:
582  return "serialattribute";
583  case 3:
584  if (fieldnum.size() == 1)
585  return "inputs";
586  switch (fieldnum[1])
587  {
588  case 0:
589  return "inputtype#";
590  case 1:
591  return "inputpointattribute#";
592  case 2:
593  return "inputvolumename#";
594  case 3:
595  return "inputvolumeresolution#";
596  case 4:
597  return "inputtuplesize#";
598 
599  }
600  return 0;
601  case 4:
602  if (fieldnum.size() == 1)
603  return "targets";
604  switch (fieldnum[1])
605  {
606  case 0:
607  return "targettype#";
608  case 1:
609  return "targetpointattribute#";
610  case 2:
611  return "targetvolumename#";
612  case 3:
613  return "targetvolumeresolution#";
614  case 4:
615  return "targettuplesize#";
616 
617  }
618  return 0;
619 
620  }
621  return 0;
622  }
623 
624  ParmType getNestParmType(TempIndex fieldnum) const override
625  {
626  if (fieldnum.size() < 1)
627  return PARM_UNSUPPORTED;
628  switch (fieldnum[0])
629  {
630  case 0:
631  return PARM_STRING;
632  case 1:
633  return PARM_STRING;
634  case 2:
635  return PARM_STRING;
636  case 3:
637  if (fieldnum.size() == 1)
638  return PARM_MULTIPARM;
639  switch (fieldnum[1])
640  {
641  case 0:
642  return PARM_INTEGER;
643  case 1:
644  return PARM_STRING;
645  case 2:
646  return PARM_STRING;
647  case 3:
648  return PARM_VECTOR3;
649  case 4:
650  return PARM_INTEGER;
651 
652  }
653  return PARM_UNSUPPORTED;
654  case 4:
655  if (fieldnum.size() == 1)
656  return PARM_MULTIPARM;
657  switch (fieldnum[1])
658  {
659  case 0:
660  return PARM_INTEGER;
661  case 1:
662  return PARM_STRING;
663  case 2:
664  return PARM_STRING;
665  case 3:
666  return PARM_VECTOR3;
667  case 4:
668  return PARM_INTEGER;
669 
670  }
671  return PARM_UNSUPPORTED;
672 
673  }
674  return PARM_UNSUPPORTED;
675  }
676 
677  // Boiler plate to load individual types.
678  static void loadData(UT_IStream &is, int64 &v)
679  { is.bread(&v, 1); }
680  static void loadData(UT_IStream &is, bool &v)
681  { int64 iv; is.bread(&iv, 1); v = iv; }
682  static void loadData(UT_IStream &is, fpreal64 &v)
683  { is.bread<fpreal64>(&v, 1); }
684  static void loadData(UT_IStream &is, UT_Vector2D &v)
685  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
686  static void loadData(UT_IStream &is, UT_Vector3D &v)
687  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
688  is.bread<fpreal64>(&v.z(), 1); }
689  static void loadData(UT_IStream &is, UT_Vector4D &v)
690  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
691  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
692  static void loadData(UT_IStream &is, UT_Matrix2D &v)
693  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
694  static void loadData(UT_IStream &is, UT_Matrix3D &v)
695  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
696  static void loadData(UT_IStream &is, UT_Matrix4D &v)
697  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
698  static void loadData(UT_IStream &is, UT_Vector2I &v)
699  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
700  static void loadData(UT_IStream &is, UT_Vector3I &v)
701  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
702  is.bread<int64>(&v.z(), 1); }
703  static void loadData(UT_IStream &is, UT_Vector4I &v)
704  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
705  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
707  { is.bread(v); }
709  { UT_StringHolder rampdata;
710  loadData(is, rampdata);
711  if (rampdata.isstring())
712  {
713  v.reset(new UT_Ramp());
714  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
715  v->load(istr);
716  }
717  else v.reset();
718  }
721  loadData(is, data);
722  if (data.isstring())
723  {
724  // Find the data type.
725  const char *colon = UT_StringWrap(data).findChar(':');
726  if (colon)
727  {
728  int typelen = colon - data.buffer();
730  type.strncpy(data.buffer(), typelen);
731  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
732 
733  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
734  }
735  }
736  else v.reset();
737  }
738 
739  static void saveData(std::ostream &os, int64 v)
740  { UTwrite(os, &v); }
741  static void saveData(std::ostream &os, bool v)
742  { int64 iv = v; UTwrite(os, &iv); }
743  static void saveData(std::ostream &os, fpreal64 v)
744  { UTwrite<fpreal64>(os, &v); }
745  static void saveData(std::ostream &os, UT_Vector2D v)
746  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
747  static void saveData(std::ostream &os, UT_Vector3D v)
748  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
749  UTwrite<fpreal64>(os, &v.z()); }
750  static void saveData(std::ostream &os, UT_Vector4D v)
751  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
752  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
753  static void saveData(std::ostream &os, UT_Matrix2D v)
755  static void saveData(std::ostream &os, UT_Matrix3D v)
757  static void saveData(std::ostream &os, UT_Matrix4D v)
759  static void saveData(std::ostream &os, UT_StringHolder s)
760  { UT_StringWrap(s).saveBinary(os); }
761  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
763  UT_OStringStream ostr;
764  if (s) s->save(ostr);
765  result = ostr.str();
766  saveData(os, result);
767  }
768  static void saveData(std::ostream &os, PRM_DataItemHandle s)
770  UT_OStringStream ostr;
771  if (s)
772  {
773  ostr << s->getDataTypeToken();
774  ostr << ":";
775  s->saveBinary(ostr);
776  }
777  result = ostr.str();
778  saveData(os, result);
779  }
780 
781 
782  void save(std::ostream &os) const
783  {
784  int32 v = version();
785  UTwrite(os, &v);
786  saveData(os, myInputDimensionAttribute);
787  saveData(os, myTargetDimensionAttribute);
788  saveData(os, mySerialAttribute);
789  {
790  int64 length = myInputs.entries();
791  UTwrite(os, &length);
792  for (exint i = 0; i < length; i++)
793  {
794  auto && _curentry = myInputs(i);
795  (void) _curentry;
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);
801 
802  }
803  }
804  {
805  int64 length = myTargets.entries();
806  UTwrite(os, &length);
807  for (exint i = 0; i < length; i++)
808  {
809  auto && _curentry = myTargets(i);
810  (void) _curentry;
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);
816 
817  }
818  }
819 
820  }
821 
822  bool load(UT_IStream &is)
823  {
824  int32 v;
825  is.bread(&v, 1);
826  if (version() != v)
827  {
828  // Fail incompatible versions
829  return false;
830  }
831  loadData(is, myInputDimensionAttribute);
832  loadData(is, myTargetDimensionAttribute);
833  loadData(is, mySerialAttribute);
834  {
835  int64 length;
836  is.read(&length, 1);
837  myInputs.setSize(length);
838  for (exint i = 0; i < length; i++)
839  {
840  auto && _curentry = myInputs(i);
841  (void) _curentry;
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);
847 
848  }
849  }
850  {
851  int64 length;
852  is.read(&length, 1);
853  myTargets.setSize(length);
854  for (exint i = 0; i < length; i++)
855  {
856  auto && _curentry = myTargets(i);
857  (void) _curentry;
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);
863 
864  }
865  }
866 
867  return true;
868  }
869 
870  const UT_StringHolder & getInputDimensionAttribute() const { return myInputDimensionAttribute; }
871  void setInputDimensionAttribute(const UT_StringHolder & val) { myInputDimensionAttribute = val; }
873  {
874  SOP_Node *thissop = cookparms.getNode();
875  if (!thissop) return getInputDimensionAttribute();
877  OP_Utils::evalOpParm(result, thissop, "inputdimensionattribute", cookparms.getCookTime(), 0);
878  return result;
879  }
880  const UT_StringHolder & getTargetDimensionAttribute() const { return myTargetDimensionAttribute; }
881  void setTargetDimensionAttribute(const UT_StringHolder & val) { myTargetDimensionAttribute = val; }
883  {
884  SOP_Node *thissop = cookparms.getNode();
885  if (!thissop) return getTargetDimensionAttribute();
887  OP_Utils::evalOpParm(result, thissop, "targetdimensionattribute", cookparms.getCookTime(), 0);
888  return result;
889  }
890  const UT_StringHolder & getSerialAttribute() const { return mySerialAttribute; }
891  void setSerialAttribute(const UT_StringHolder & val) { mySerialAttribute = val; }
893  {
894  SOP_Node *thissop = cookparms.getNode();
895  if (!thissop) return getSerialAttribute();
897  OP_Utils::evalOpParm(result, thissop, "serialattribute", cookparms.getCookTime(), 0);
898  return result;
899  }
900  const UT_Array<Inputs> &getInputs() const { return myInputs; }
901 void setInputs(const UT_Array<Inputs> &val) { myInputs = val; }
902  exint opInputs(const SOP_NodeVerb::CookParms &cookparms) const
903  {
904  SOP_Node *thissop = cookparms.getNode();
905  if (!thissop) return getInputs().entries();
906  exint result;
907  OP_Utils::evalOpParm(result, thissop, "inputs", cookparms.getCookTime(), 0);
908  return result;
909  }
910  int64 opInputs_inputtype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
911  { return opinstInputs_inputtype(cookparms, &_idx); }
912  int64 opinstInputs_inputtype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
913  {
914  SOP_Node *thissop = cookparms.getNode();
915  if (!thissop) return (myInputs(_idx[0]).inputtype);
916  int _parmidx[2-1];
917  _parmidx[1-1] = _idx[1-1] + 1;
918 
919  int64 result;
920  OP_Utils::evalOpParmInst(result, thissop, "inputtype#", _parmidx, cookparms.getCookTime(), 0, 2-1);
921  return (result);
922  }
924  { return opinstInputs_inputpointattribute(cookparms, &_idx); }
926  {
927  SOP_Node *thissop = cookparms.getNode();
928  if (!thissop) return (myInputs(_idx[0]).inputpointattribute);
929  int _parmidx[2-1];
930  _parmidx[1-1] = _idx[1-1] + 1;
931 
933  OP_Utils::evalOpParmInst(result, thissop, "inputpointattribute#", _parmidx, cookparms.getCookTime(), 0, 2-1);
934  return (result);
935  }
937  { return opinstInputs_inputvolumename(cookparms, &_idx); }
939  {
940  SOP_Node *thissop = cookparms.getNode();
941  if (!thissop) return (myInputs(_idx[0]).inputvolumename);
942  int _parmidx[2-1];
943  _parmidx[1-1] = _idx[1-1] + 1;
944 
946  OP_Utils::evalOpParmInst(result, thissop, "inputvolumename#", _parmidx, cookparms.getCookTime(), 0, 2-1);
947  return (result);
948  }
950  { return opinstInputs_inputvolumeresolution(cookparms, &_idx); }
952  {
953  SOP_Node *thissop = cookparms.getNode();
954  if (!thissop) return (myInputs(_idx[0]).inputvolumeresolution);
955  int _parmidx[2-1];
956  _parmidx[1-1] = _idx[1-1] + 1;
957 
959  OP_Utils::evalOpParmInst(result, thissop, "inputvolumeresolution#", _parmidx, cookparms.getCookTime(), 0, 2-1);
960  return (result);
961  }
962  int64 opInputs_inputtuplesize(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
963  { return opinstInputs_inputtuplesize(cookparms, &_idx); }
964  int64 opinstInputs_inputtuplesize(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
965  {
966  SOP_Node *thissop = cookparms.getNode();
967  if (!thissop) return (myInputs(_idx[0]).inputtuplesize);
968  int _parmidx[2-1];
969  _parmidx[1-1] = _idx[1-1] + 1;
970 
971  int64 result;
972  OP_Utils::evalOpParmInst(result, thissop, "inputtuplesize#", _parmidx, cookparms.getCookTime(), 0, 2-1);
973  return (result);
974  }
975 
976  const UT_Array<Targets> &getTargets() const { return myTargets; }
977 void setTargets(const UT_Array<Targets> &val) { myTargets = val; }
978  exint opTargets(const SOP_NodeVerb::CookParms &cookparms) const
979  {
980  SOP_Node *thissop = cookparms.getNode();
981  if (!thissop) return getTargets().entries();
982  exint result;
983  OP_Utils::evalOpParm(result, thissop, "targets", cookparms.getCookTime(), 0);
984  return result;
985  }
986  int64 opTargets_targettype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
987  { return opinstTargets_targettype(cookparms, &_idx); }
988  int64 opinstTargets_targettype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
989  {
990  SOP_Node *thissop = cookparms.getNode();
991  if (!thissop) return (myTargets(_idx[0]).targettype);
992  int _parmidx[2-1];
993  _parmidx[1-1] = _idx[1-1] + 1;
994 
995  int64 result;
996  OP_Utils::evalOpParmInst(result, thissop, "targettype#", _parmidx, cookparms.getCookTime(), 0, 2-1);
997  return (result);
998  }
1000  { return opinstTargets_targetpointattribute(cookparms, &_idx); }
1002  {
1003  SOP_Node *thissop = cookparms.getNode();
1004  if (!thissop) return (myTargets(_idx[0]).targetpointattribute);
1005  int _parmidx[2-1];
1006  _parmidx[1-1] = _idx[1-1] + 1;
1007 
1009  OP_Utils::evalOpParmInst(result, thissop, "targetpointattribute#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1010  return (result);
1011  }
1013  { return opinstTargets_targetvolumename(cookparms, &_idx); }
1015  {
1016  SOP_Node *thissop = cookparms.getNode();
1017  if (!thissop) return (myTargets(_idx[0]).targetvolumename);
1018  int _parmidx[2-1];
1019  _parmidx[1-1] = _idx[1-1] + 1;
1020 
1022  OP_Utils::evalOpParmInst(result, thissop, "targetvolumename#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1023  return (result);
1024  }
1026  { return opinstTargets_targetvolumeresolution(cookparms, &_idx); }
1028  {
1029  SOP_Node *thissop = cookparms.getNode();
1030  if (!thissop) return (myTargets(_idx[0]).targetvolumeresolution);
1031  int _parmidx[2-1];
1032  _parmidx[1-1] = _idx[1-1] + 1;
1033 
1035  OP_Utils::evalOpParmInst(result, thissop, "targetvolumeresolution#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1036  return (result);
1037  }
1038  int64 opTargets_targettuplesize(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1039  { return opinstTargets_targettuplesize(cookparms, &_idx); }
1040  int64 opinstTargets_targettuplesize(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1041  {
1042  SOP_Node *thissop = cookparms.getNode();
1043  if (!thissop) return (myTargets(_idx[0]).targettuplesize);
1044  int _parmidx[2-1];
1045  _parmidx[1-1] = _idx[1-1] + 1;
1046 
1047  int64 result;
1048  OP_Utils::evalOpParmInst(result, thissop, "targettuplesize#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1049  return (result);
1050  }
1051 
1052 
1053 private:
1054  UT_StringHolder myInputDimensionAttribute;
1055  UT_StringHolder myTargetDimensionAttribute;
1056  UT_StringHolder mySerialAttribute;
1057  UT_Array<Inputs> myInputs;
1058  UT_Array<Targets> myTargets;
1059 
1060 };
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
type
Definition: core.h:556
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
Definition: glcorearb.h:2540
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
int int32
Definition: SYS_Types.h:39
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:347
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
void
Definition: png.h:1083
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
GLboolean * data
Definition: glcorearb.h:131
bool operator==(const SOP_MLExampleDeserializePackedParms &src) const
GT_API const UT_StringHolder time
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector4.h:493
const GLdouble * v
Definition: glcorearb.h:837
fpreal getTime() const
Definition: OP_Context.h:63
GLsizei const GLfloat * value
Definition: glcorearb.h:824
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)
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
Definition: OP_NodeParms.h:97
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector3.h:667
int64 exint
Definition: SYS_Types.h:125
UT_Vector3I opTargets_targetvolumeresolution(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
SYS_FORCE_INLINE const char * buffer() const
exint opTargets(const SOP_NodeVerb::CookParms &cookparms) const
GLdouble s
Definition: glad.h:3009
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:795
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
Definition: thread.h:622
UT_Vector3T< int64 > UT_Vector3I
UT_StringHolder opTargetDimensionAttribute(const SOP_NodeVerb::CookParms &cookparms) const
exint nodeIdx() const
Definition: OP_NodeParms.h:95
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector4.h:491
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
Definition: glcorearb.h:2621
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
double fpreal64
Definition: SYS_Types.h:201
int64 opInputs_inputtype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: APEX_Include.h:55
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector2.h:423
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)
Definition: Dimensions.h:137
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
exint length() 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.
Definition: UT_SharedPtr.h:36
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector4.h:495
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:276
const OP_GraphProxy * graph() const
Definition: OP_NodeParms.h:94
static void loadData(UT_IStream &is, int64 &v)
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
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
long long int64
Definition: SYS_Types.h:116
const UT_StringHolder & getTargetDimensionAttribute() const
UT_StringHolder createString(const UT_Array< Inputs > &list) const
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
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.
Definition: UT_String.h:303
GT_API const UT_StringHolder version
int64 opTargets_targettype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
#define SYS_PRId64
Definition: SYS_Types.h:76
exint entries() const
Alias of size(). size() is preferred.
Definition: UT_Array.h:655
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
fpreal64 fpreal
Definition: SYS_Types.h:278
DEP_MicroNode * depnode() const
Definition: OP_NodeParms.h:99
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.
Definition: UT_Ramp.h:96
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
Definition: UT_Vector4.h:497
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)
GLuint GLfloat * val
Definition: glcorearb.h:1608
virtual UT_StringHolder baseGetSignature() const
Definition: OP_NodeParms.h:294
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
#define SOP_API
Definition: SOP_API.h:10
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
Definition: SOP_NodeVerb.h:372
static void loadData(UT_IStream &is, UT_Vector2D &v)
const char * findChar(int c) const
Definition: UT_String.h:1401
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
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
GLboolean r
Definition: glcorearb.h:1222
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)
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector3.h:665
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
const UT_StringHolder & getInputDimensionAttribute() const
virtual bool isDirect() const =0
Direct proxies mirror actual nodes:
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
Definition: UT_Vector2.h:425
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)
GLenum src
Definition: glcorearb.h:1793
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector3.h:663