HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_Curve.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_NodeVerb.h>
7 #include <OP/OP_Utils.h>
8 #include <PRM/PRM_Parm.h>
9 #include <UT/UT_IStream.h>
10 #include <UT/UT_NTStreamUtil.h>
11 #include <UT/UT_Ramp.h>
12 #include <UT/UT_SharedPtr.h>
13 #include <UT/UT_StringHolder.h>
14 #include <UT/UT_StringStream.h>
15 #include <UT/UT_VectorTypes.h>
16 #include <SYS/SYS_Types.h>
17 
18 using namespace UT::Literal;
19 
20 class DEP_MicroNode;
21 namespace SOP_CurveEnums
22 {
23  enum class Type
24  {
25  POLY = 0,
26  NURBS,
27  BEZIER
28  };
29  enum class Method
30  {
31  CV = 0,
32  BREAKPOINTS,
33  FREEHAND
34  };
35  enum class Param
36  {
37  UNIFORM = 0,
38  CHRDLEN,
39  CENTRIP
40  };
41 }
42 
43 
45 {
46 public:
47  static int version() { return 1; }
48 
50  {
51  myType = 0;
52  myMethod = 0;
53  myCoords = ""_sh;
54  myClose = false;
55  myReverse = false;
56  myOrder = 4;
57  myParam = 0;
58  myTolerance = 0.01;
59  mySmooth = 0;
60  myCsharp = false;
61  myKeepgeo = false;
62  myNormalize = false;
63 
64  }
65 
66  explicit SOP_CurveParms(const SOP_CurveParms &) = default;
67 
68  virtual ~SOP_CurveParms() {}
69 
70  bool operator==(const SOP_CurveParms &src) const
71  {
72  if (myType != src.myType) return false;
73  if (myMethod != src.myMethod) return false;
74  if (myCoords != src.myCoords) return false;
75  if (myClose != src.myClose) return false;
76  if (myReverse != src.myReverse) return false;
77  if (myOrder != src.myOrder) return false;
78  if (myParam != src.myParam) return false;
79  if (myTolerance != src.myTolerance) return false;
80  if (mySmooth != src.mySmooth) return false;
81  if (myCsharp != src.myCsharp) return false;
82  if (myKeepgeo != src.myKeepgeo) return false;
83  if (myNormalize != src.myNormalize) return false;
84 
85  return true;
86  }
87  bool operator!=(const SOP_CurveParms &src) const
88  {
89  return !operator==(src);
90  }
94 
95 
96 
97  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
98  {
99  if (true)
100  OP_Utils::evalOpParm(myType, node, "type", time, 0);
101  else myType = 0;
102  if (true)
103  OP_Utils::evalOpParm(myMethod, node, "method", time, 0);
104  else myMethod = 0;
105  if (true)
106  OP_Utils::evalOpParm(myCoords, node, "coords", time, 0);
107  else myCoords = ""_sh;
108  if (true)
109  OP_Utils::evalOpParm(myClose, node, "close", time, 0);
110  else myClose = false;
111  if (true)
112  OP_Utils::evalOpParm(myReverse, node, "reverse", time, 0);
113  else myReverse = false;
114  if (true && ( (!(((int64(getType())==0)))) ) )
115  OP_Utils::evalOpParm(myOrder, node, "order", time, 0);
116  else myOrder = 4;
117  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=1)))) ) )
118  OP_Utils::evalOpParm(myParam, node, "param", time, 0);
119  else myParam = 0;
120  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=2)))) ) )
121  OP_Utils::evalOpParm(myTolerance, node, "tolerance", time, 0);
122  else myTolerance = 0.01;
123  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=2)))) ) )
124  OP_Utils::evalOpParm(mySmooth, node, "smooth", time, 0);
125  else mySmooth = 0;
126  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=2)))) ) )
127  OP_Utils::evalOpParm(myCsharp, node, "csharp", time, 0);
128  else myCsharp = false;
129  if (true)
130  OP_Utils::evalOpParm(myKeepgeo, node, "keepgeo", time, 0);
131  else myKeepgeo = false;
132  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=1))||((int64(getParam())!=0)))) ) )
133  OP_Utils::evalOpParm(myNormalize, node, "normalize", time, 0);
134  else myNormalize = false;
135 
136  }
137 
138 
139  virtual void loadFromOpSubclass(const LoadParms &loadparms)
140  {
141  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
142  }
143 
144 
145  virtual void copyFrom(const SOP_NodeParms *src)
146  {
147  *this = *((const SOP_CurveParms *)src);
148  }
149 
150  template <typename T>
151  void
152  doGetParmValue(exint idx, T &value) const
153  {
154  switch (idx)
155  {
156  case 0:
157  coerceValue(value, myType);
158  break;
159  case 1:
160  coerceValue(value, myMethod);
161  break;
162  case 2:
163  coerceValue(value, myCoords);
164  break;
165  case 3:
166  coerceValue(value, myClose);
167  break;
168  case 4:
169  coerceValue(value, myReverse);
170  break;
171  case 5:
172  coerceValue(value, myOrder);
173  break;
174  case 6:
175  coerceValue(value, myParam);
176  break;
177  case 7:
178  coerceValue(value, myTolerance);
179  break;
180  case 8:
181  coerceValue(value, mySmooth);
182  break;
183  case 9:
184  coerceValue(value, myCsharp);
185  break;
186  case 10:
187  coerceValue(value, myKeepgeo);
188  break;
189  case 11:
190  coerceValue(value, myNormalize);
191  break;
192 
193  }
194  }
195 
196  void getParmValue(exint idx, exint &value) const
197  { doGetParmValue(idx, value); }
198  void getParmValue(exint idx, fpreal &value) const
199  { doGetParmValue(idx, value); }
201  { doGetParmValue(idx, value); }
203  { doGetParmValue(idx, value); }
205  { doGetParmValue(idx, value); }
207  { doGetParmValue(idx, value); }
209  { doGetParmValue(idx, value); }
211  { doGetParmValue(idx, value); }
213  { doGetParmValue(idx, value); }
215  { doGetParmValue(idx, value); }
217  { doGetParmValue(idx, value); }
218 
219  template <typename T>
220  void
221  doSetParmValue(exint idx, const T &value)
222  {
223  switch (idx)
224  {
225  case 0:
226  coerceValue(myType, value);
227  break;
228  case 1:
229  coerceValue(myMethod, value);
230  break;
231  case 2:
232  coerceValue(myCoords, value);
233  break;
234  case 3:
235  coerceValue(myClose, value);
236  break;
237  case 4:
238  coerceValue(myReverse, value);
239  break;
240  case 5:
241  coerceValue(myOrder, value);
242  break;
243  case 6:
244  coerceValue(myParam, value);
245  break;
246  case 7:
247  coerceValue(myTolerance, value);
248  break;
249  case 8:
250  coerceValue(mySmooth, value);
251  break;
252  case 9:
253  coerceValue(myCsharp, value);
254  break;
255  case 10:
256  coerceValue(myKeepgeo, value);
257  break;
258  case 11:
259  coerceValue(myNormalize, value);
260  break;
261 
262  }
263  }
264 
265  void setParmValue(exint idx, const exint &value)
266  { doSetParmValue(idx, value); }
267  void setParmValue(exint idx, const fpreal &value)
268  { doSetParmValue(idx, value); }
269  void setParmValue(exint idx, const UT_Vector2D &value)
270  { doSetParmValue(idx, value); }
271  void setParmValue(exint idx, const UT_Vector3D &value)
272  { doSetParmValue(idx, value); }
273  void setParmValue(exint idx, const UT_Vector4D &value)
274  { doSetParmValue(idx, value); }
275  void setParmValue(exint idx, const UT_Matrix2D &value)
276  { doSetParmValue(idx, value); }
277  void setParmValue(exint idx, const UT_Matrix3D &value)
278  { doSetParmValue(idx, value); }
279  void setParmValue(exint idx, const UT_Matrix4D &value)
280  { doSetParmValue(idx, value); }
282  { doSetParmValue(idx, value); }
284  { doSetParmValue(idx, value); }
286  { doSetParmValue(idx, value); }
287 
288  virtual exint getNumParms() const
289  {
290  return 12;
291  }
292 
293  virtual const char *getParmName(exint fieldnum) const
294  {
295  switch (fieldnum)
296  {
297  case 0:
298  return "type";
299  case 1:
300  return "method";
301  case 2:
302  return "coords";
303  case 3:
304  return "close";
305  case 4:
306  return "reverse";
307  case 5:
308  return "order";
309  case 6:
310  return "param";
311  case 7:
312  return "tolerance";
313  case 8:
314  return "smooth";
315  case 9:
316  return "csharp";
317  case 10:
318  return "keepgeo";
319  case 11:
320  return "normalize";
321 
322  }
323  return 0;
324  }
325 
326  virtual ParmType getParmType(exint fieldnum) const
327  {
328  switch (fieldnum)
329  {
330  case 0:
331  return PARM_INTEGER;
332  case 1:
333  return PARM_INTEGER;
334  case 2:
335  return PARM_STRING;
336  case 3:
337  return PARM_INTEGER;
338  case 4:
339  return PARM_INTEGER;
340  case 5:
341  return PARM_INTEGER;
342  case 6:
343  return PARM_INTEGER;
344  case 7:
345  return PARM_FLOAT;
346  case 8:
347  return PARM_FLOAT;
348  case 9:
349  return PARM_INTEGER;
350  case 10:
351  return PARM_INTEGER;
352  case 11:
353  return PARM_INTEGER;
354 
355  }
356  return PARM_UNSUPPORTED;
357  }
358 
359  // Boiler plate to load individual types.
360  static void loadData(UT_IStream &is, int64 &v)
361  { is.bread(&v, 1); }
362  static void loadData(UT_IStream &is, bool &v)
363  { int64 iv; is.bread(&iv, 1); v = iv; }
364  static void loadData(UT_IStream &is, fpreal64 &v)
365  { is.bread<fpreal64>(&v, 1); }
366  static void loadData(UT_IStream &is, UT_Vector2D &v)
367  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
368  static void loadData(UT_IStream &is, UT_Vector3D &v)
369  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
370  is.bread<fpreal64>(&v.z(), 1); }
371  static void loadData(UT_IStream &is, UT_Vector4D &v)
372  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
373  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
374  static void loadData(UT_IStream &is, UT_Matrix2D &v)
375  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
376  static void loadData(UT_IStream &is, UT_Matrix3D &v)
377  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
378  static void loadData(UT_IStream &is, UT_Matrix4D &v)
379  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
380  static void loadData(UT_IStream &is, UT_Vector2I &v)
381  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
382  static void loadData(UT_IStream &is, UT_Vector3I &v)
383  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
384  is.bread<int64>(&v.z(), 1); }
385  static void loadData(UT_IStream &is, UT_Vector4I &v)
386  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
387  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
389  { is.bread(v); }
391  { UT_StringHolder rampdata;
392  loadData(is, rampdata);
393  if (rampdata.isstring())
394  {
395  v.reset(new UT_Ramp());
396  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
397  v->load(istr);
398  }
399  else v.reset();
400  }
403  loadData(is, data);
404  if (data.isstring())
405  {
406  // Find the data type.
407  char *colon = UT_StringWrap(data).findChar(':');
408  if (colon)
409  {
410  int typelen = colon - data.buffer();
412  type.strncpy(data.buffer(), typelen);
413  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
414 
415  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
416  }
417  }
418  else v.reset();
419  }
420 
421  static void saveData(std::ostream &os, int64 v)
422  { UTwrite(os, &v); }
423  static void saveData(std::ostream &os, bool v)
424  { int64 iv = v; UTwrite(os, &iv); }
425  static void saveData(std::ostream &os, fpreal64 v)
426  { UTwrite<fpreal64>(os, &v); }
427  static void saveData(std::ostream &os, UT_Vector2D v)
428  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
429  static void saveData(std::ostream &os, UT_Vector3D v)
430  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
431  UTwrite<fpreal64>(os, &v.z()); }
432  static void saveData(std::ostream &os, UT_Vector4D v)
433  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
434  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
435  static void saveData(std::ostream &os, UT_Matrix2D v)
437  static void saveData(std::ostream &os, UT_Matrix3D v)
439  static void saveData(std::ostream &os, UT_Matrix4D v)
441  static void saveData(std::ostream &os, UT_StringHolder s)
442  { UT_StringWrap(s).saveBinary(os); }
443  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
444  { UT_StringHolder result;
445  UT_OStringStream ostr;
446  if (s) s->save(ostr);
447  result = ostr.str();
448  saveData(os, result);
449  }
450  static void saveData(std::ostream &os, PRM_DataItemHandle s)
451  { UT_StringHolder result;
452  UT_OStringStream ostr;
453  if (s)
454  {
455  ostr << s->getDataTypeToken();
456  ostr << ":";
457  s->saveBinary(ostr);
458  }
459  result = ostr.str();
460  saveData(os, result);
461  }
462 
463 
464  void save(std::ostream &os) const
465  {
466  int32 v = version();
467  UTwrite(os, &v);
468  saveData(os, myType);
469  saveData(os, myMethod);
470  saveData(os, myCoords);
471  saveData(os, myClose);
472  saveData(os, myReverse);
473  saveData(os, myOrder);
474  saveData(os, myParam);
475  saveData(os, myTolerance);
476  saveData(os, mySmooth);
477  saveData(os, myCsharp);
478  saveData(os, myKeepgeo);
479  saveData(os, myNormalize);
480 
481  }
482 
483  bool load(UT_IStream &is)
484  {
485  int32 v;
486  is.bread(&v, 1);
487  if (version() != v)
488  {
489  // Fail incompatible versions
490  return false;
491  }
492  loadData(is, myType);
493  loadData(is, myMethod);
494  loadData(is, myCoords);
495  loadData(is, myClose);
496  loadData(is, myReverse);
497  loadData(is, myOrder);
498  loadData(is, myParam);
499  loadData(is, myTolerance);
500  loadData(is, mySmooth);
501  loadData(is, myCsharp);
502  loadData(is, myKeepgeo);
503  loadData(is, myNormalize);
504 
505  return true;
506  }
507 
508  Type getType() const { return Type(myType); }
509  void setType(Type val) { myType = int64(val); }
510  Type opType(const SOP_NodeVerb::CookParms &cookparms) const
511  {
512  SOP_Node *thissop = cookparms.getNode();
513  if (!thissop) return getType();
514  int64 result;
515  OP_Utils::evalOpParm(result, thissop, "type", cookparms.getCookTime(), 0);
516  return Type(result);
517  }
518  Method getMethod() const { return Method(myMethod); }
519  void setMethod(Method val) { myMethod = int64(val); }
520  Method opMethod(const SOP_NodeVerb::CookParms &cookparms) const
521  {
522  SOP_Node *thissop = cookparms.getNode();
523  if (!thissop) return getMethod();
524  int64 result;
525  OP_Utils::evalOpParm(result, thissop, "method", cookparms.getCookTime(), 0);
526  return Method(result);
527  }
528  const UT_StringHolder & getCoords() const { return myCoords; }
529  void setCoords(const UT_StringHolder & val) { myCoords = val; }
531  {
532  SOP_Node *thissop = cookparms.getNode();
533  if (!thissop) return getCoords();
534  UT_StringHolder result;
535  OP_Utils::evalOpParm(result, thissop, "coords", cookparms.getCookTime(), 0);
536  return result;
537  }
538  bool getClose() const { return myClose; }
539  void setClose(bool val) { myClose = val; }
540  bool opClose(const SOP_NodeVerb::CookParms &cookparms) const
541  {
542  SOP_Node *thissop = cookparms.getNode();
543  if (!thissop) return getClose();
544  bool result;
545  OP_Utils::evalOpParm(result, thissop, "close", cookparms.getCookTime(), 0);
546  return result;
547  }
548  bool getReverse() const { return myReverse; }
549  void setReverse(bool val) { myReverse = val; }
550  bool opReverse(const SOP_NodeVerb::CookParms &cookparms) const
551  {
552  SOP_Node *thissop = cookparms.getNode();
553  if (!thissop) return getReverse();
554  bool result;
555  OP_Utils::evalOpParm(result, thissop, "reverse", cookparms.getCookTime(), 0);
556  return result;
557  }
558  int64 getOrder() const { return myOrder; }
559  void setOrder(int64 val) { myOrder = val; }
560  int64 opOrder(const SOP_NodeVerb::CookParms &cookparms) const
561  {
562  SOP_Node *thissop = cookparms.getNode();
563  if (!thissop) return getOrder();
564  int64 result;
565  OP_Utils::evalOpParm(result, thissop, "order", cookparms.getCookTime(), 0);
566  return result;
567  }
568  Param getParam() const { return Param(myParam); }
569  void setParam(Param val) { myParam = int64(val); }
570  Param opParam(const SOP_NodeVerb::CookParms &cookparms) const
571  {
572  SOP_Node *thissop = cookparms.getNode();
573  if (!thissop) return getParam();
574  int64 result;
575  OP_Utils::evalOpParm(result, thissop, "param", cookparms.getCookTime(), 0);
576  return Param(result);
577  }
578  fpreal64 getTolerance() const { return myTolerance; }
579  void setTolerance(fpreal64 val) { myTolerance = val; }
581  {
582  SOP_Node *thissop = cookparms.getNode();
583  if (!thissop) return getTolerance();
584  fpreal64 result;
585  OP_Utils::evalOpParm(result, thissop, "tolerance", cookparms.getCookTime(), 0);
586  return result;
587  }
588  fpreal64 getSmooth() const { return mySmooth; }
589  void setSmooth(fpreal64 val) { mySmooth = val; }
590  fpreal64 opSmooth(const SOP_NodeVerb::CookParms &cookparms) const
591  {
592  SOP_Node *thissop = cookparms.getNode();
593  if (!thissop) return getSmooth();
594  fpreal64 result;
595  OP_Utils::evalOpParm(result, thissop, "smooth", cookparms.getCookTime(), 0);
596  return result;
597  }
598  bool getCsharp() const { return myCsharp; }
599  void setCsharp(bool val) { myCsharp = val; }
600  bool opCsharp(const SOP_NodeVerb::CookParms &cookparms) const
601  {
602  SOP_Node *thissop = cookparms.getNode();
603  if (!thissop) return getCsharp();
604  bool result;
605  OP_Utils::evalOpParm(result, thissop, "csharp", cookparms.getCookTime(), 0);
606  return result;
607  }
608  bool getKeepgeo() const { return myKeepgeo; }
609  void setKeepgeo(bool val) { myKeepgeo = val; }
610  bool opKeepgeo(const SOP_NodeVerb::CookParms &cookparms) const
611  {
612  SOP_Node *thissop = cookparms.getNode();
613  if (!thissop) return getKeepgeo();
614  bool result;
615  OP_Utils::evalOpParm(result, thissop, "keepgeo", cookparms.getCookTime(), 0);
616  return result;
617  }
618  bool getNormalize() const { return myNormalize; }
619  void setNormalize(bool val) { myNormalize = val; }
620  bool opNormalize(const SOP_NodeVerb::CookParms &cookparms) const
621  {
622  SOP_Node *thissop = cookparms.getNode();
623  if (!thissop) return getNormalize();
624  bool result;
625  OP_Utils::evalOpParm(result, thissop, "normalize", cookparms.getCookTime(), 0);
626  return result;
627  }
628 
629 private:
630  int64 myType;
631  int64 myMethod;
632  UT_StringHolder myCoords;
633  bool myClose;
634  bool myReverse;
635  int64 myOrder;
636  int64 myParam;
637  fpreal64 myTolerance;
638  fpreal64 mySmooth;
639  bool myCsharp;
640  bool myKeepgeo;
641  bool myNormalize;
642 
643 };
void getParmValue(exint idx, UT_Vector2D &value) const
int64 getOrder() const
void setParmValue(exint idx, const UT_Vector3D &value)
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:494
T & z(void)
Definition: UT_Vector4.h:379
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void setParam(Param val)
static void loadData(UT_IStream &is, fpreal64 &v)
static void loadData(UT_IStream &is, UT_Vector2D &v)
int myOrder
Definition: GT_CurveEval.h:263
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool getClose() const
void setType(Type val)
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
bool opKeepgeo(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getTime() const
Definition: OP_Context.h:60
const GLdouble * v
Definition: glcorearb.h:836
void doSetParmValue(exint idx, const T &value)
void setParmValue(exint idx, const UT_Vector2D &value)
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void setParmValue(exint idx, const UT_Matrix4D &value)
void setParmValue(exint idx, const exint &value)
void getParmValue(exint idx, PRM_DataItemHandle &value) const
static void saveData(std::ostream &os, UT_Vector2D v)
void save(std::ostream &os) const
static void loadData(UT_IStream &is, int64 &v)
static void saveData(std::ostream &os, int64 v)
void setSmooth(fpreal64 val)
SYS_FORCE_INLINE const char * buffer() const
virtual ParmType getParmType(exint fieldnum) const
T & x(void)
Definition: UT_Vector2.h:285
void setParmValue(exint idx, const UT_Matrix3D &value)
bool load(UT_IStream &is)
An output stream object that owns its own string buffer storage.
void setTolerance(fpreal64 val)
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
void getParmValue(exint idx, UT_StringHolder &value) const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:498
Type getType() const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void setReverse(bool val)
void setCsharp(bool val)
static void saveData(std::ostream &os, UT_Vector3D v)
void setClose(bool val)
void setKeepgeo(bool val)
virtual void loadFromOpSubclass(const LoadParms &loadparms)
static void saveData(std::ostream &os, UT_Matrix3D v)
static void loadData(UT_IStream &is, UT_Vector3I &v)
Method opMethod(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Matrix4D &value) const
void setMethod(Method val)
static void loadData(UT_IStream &is, bool &v)
static void loadData(UT_IStream &is, UT_Vector2I &v)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:502
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
static void loadData(UT_IStream &is, UT_StringHolder &v)
long long int64
Definition: SYS_Types.h:107
void getParmValue(exint idx, exint &value) const
fpreal64 getTolerance() const
void getParmValue(exint idx, fpreal &value) const
void setParmValue(exint idx, const fpreal &value)
bool opReverse(const SOP_NodeVerb::CookParms &cookparms) const
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
fpreal64 getSmooth() const
UT_StringHolder opCoords(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
int64 exint
Definition: SYS_Types.h:116
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:192
static void saveData(std::ostream &os, bool v)
fpreal64 opTolerance(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Matrix3D &value) const
void getParmValue(exint idx, UT_Vector4D &value) const
virtual const char * getParmName(exint fieldnum) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
static void loadData(UT_IStream &is, UT_Vector4D &v)
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
static void saveData(std::ostream &os, UT_Vector4D v)
bool operator!=(const SOP_CurveParms &src) const
static void saveData(std::ostream &os, UT_Matrix4D v)
GLboolean * data
Definition: glcorearb.h:130
bool opNormalize(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Matrix2D &value)
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
int int32
Definition: SYS_Types.h:35
void setParmValue(exint idx, const UT_Vector4D &value)
T & y(void)
Definition: UT_Vector4.h:377
void setParmValue(exint idx, const PRM_DataItemHandle &value)
void setCoords(const UT_StringHolder &val)
static void saveData(std::ostream &os, fpreal64 v)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
static void loadData(UT_IStream &is, UT_Matrix2D &v)
bool getCsharp() const
bool getNormalize() const
Type opType(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:500
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:270
int64 opOrder(const SOP_NodeVerb::CookParms &cookparms) const
void setOrder(int64 val)
virtual ~SOP_CurveParms()
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
const UT_StringHolder & getCoords() const
bool opCsharp(const SOP_NodeVerb::CookParms &cookparms) const
GLuint GLfloat * val
Definition: glcorearb.h:1607
static int version()
#define SOP_API
Definition: SOP_API.h:10
bool opClose(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const SOP_CurveParms &src) const
Param getParam() const
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:501
T & x(void)
Definition: UT_Vector4.h:375
static void saveData(std::ostream &os, UT_StringHolder s)
void setNormalize(bool val)
T & y(void)
Definition: UT_Vector2.h:287
virtual exint getNumParms() const
GLboolean r
Definition: glcorearb.h:1221
void getParmValue(exint idx, UT_Matrix2D &value) const
virtual void copyFrom(const SOP_NodeParms *src)
T & w(void)
Definition: UT_Vector4.h:381
void doGetParmValue(exint idx, T &value) const
bool getReverse() const
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
Method getMethod() const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:88
fpreal64 opSmooth(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
Param opParam(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_StringHolder &value)
bool getKeepgeo() const
static void loadData(UT_IStream &is, UT_Vector3D &v)
static void saveData(std::ostream &os, UT_Matrix2D v)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
GLenum src
Definition: glcorearb.h:1792
void getParmValue(exint idx, UT_Vector3D &value) const