HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros 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  }
90 
91 
92 
93  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
94  {
95  if (true)
96  OP_Utils::evalOpParm(myType, node, "type", time, 0);
97  else myType = 0;
98  if (true)
99  OP_Utils::evalOpParm(myMethod, node, "method", time, 0);
100  else myMethod = 0;
101  if (true)
102  OP_Utils::evalOpParm(myCoords, node, "coords", time, 0);
103  else myCoords = ""_sh;
104  if (true)
105  OP_Utils::evalOpParm(myClose, node, "close", time, 0);
106  else myClose = false;
107  if (true)
108  OP_Utils::evalOpParm(myReverse, node, "reverse", time, 0);
109  else myReverse = false;
110  if (true && ( (!(((int64(getType())==0)))) ) )
111  OP_Utils::evalOpParm(myOrder, node, "order", time, 0);
112  else myOrder = 4;
113  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=1)))) ) )
114  OP_Utils::evalOpParm(myParam, node, "param", time, 0);
115  else myParam = 0;
116  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=2)))) ) )
117  OP_Utils::evalOpParm(myTolerance, node, "tolerance", time, 0);
118  else myTolerance = 0.01;
119  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=2)))) ) )
120  OP_Utils::evalOpParm(mySmooth, node, "smooth", time, 0);
121  else mySmooth = 0;
122  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=2)))) ) )
123  OP_Utils::evalOpParm(myCsharp, node, "csharp", time, 0);
124  else myCsharp = false;
125  if (true)
126  OP_Utils::evalOpParm(myKeepgeo, node, "keepgeo", time, 0);
127  else myKeepgeo = false;
128  if (true && ( (!(((int64(getType())==0))||((int64(getMethod())!=1))||((int64(getParam())!=0)))) ) )
129  OP_Utils::evalOpParm(myNormalize, node, "normalize", time, 0);
130  else myNormalize = false;
131 
132  }
133 
134 
135  virtual void loadFromOpSubclass(const LoadParms &loadparms)
136  {
137  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
138  }
139 
140 
141  virtual void copyFrom(const SOP_NodeParms *src)
142  {
143  *this = *((const SOP_CurveParms *)src);
144  }
145 
146  template <typename T>
147  void
148  doGetParmValue(exint idx, T &value) const
149  {
150  switch (idx)
151  {
152  case 0:
153  coerceValue(value, myType);
154  break;
155  case 1:
156  coerceValue(value, myMethod);
157  break;
158  case 2:
159  coerceValue(value, myCoords);
160  break;
161  case 3:
162  coerceValue(value, myClose);
163  break;
164  case 4:
165  coerceValue(value, myReverse);
166  break;
167  case 5:
168  coerceValue(value, myOrder);
169  break;
170  case 6:
171  coerceValue(value, myParam);
172  break;
173  case 7:
174  coerceValue(value, myTolerance);
175  break;
176  case 8:
177  coerceValue(value, mySmooth);
178  break;
179  case 9:
180  coerceValue(value, myCsharp);
181  break;
182  case 10:
183  coerceValue(value, myKeepgeo);
184  break;
185  case 11:
186  coerceValue(value, myNormalize);
187  break;
188 
189  }
190  }
191 
192  void getParmValue(exint idx, exint &value) const
193  { doGetParmValue(idx, value); }
194  void getParmValue(exint idx, fpreal &value) const
195  { doGetParmValue(idx, value); }
197  { doGetParmValue(idx, value); }
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); }
214 
215  template <typename T>
216  void
217  doSetParmValue(exint idx, const T &value)
218  {
219  switch (idx)
220  {
221  case 0:
222  coerceValue(myType, value);
223  break;
224  case 1:
225  coerceValue(myMethod, value);
226  break;
227  case 2:
228  coerceValue(myCoords, value);
229  break;
230  case 3:
231  coerceValue(myClose, value);
232  break;
233  case 4:
234  coerceValue(myReverse, value);
235  break;
236  case 5:
237  coerceValue(myOrder, value);
238  break;
239  case 6:
240  coerceValue(myParam, value);
241  break;
242  case 7:
243  coerceValue(myTolerance, value);
244  break;
245  case 8:
246  coerceValue(mySmooth, value);
247  break;
248  case 9:
249  coerceValue(myCsharp, value);
250  break;
251  case 10:
252  coerceValue(myKeepgeo, value);
253  break;
254  case 11:
255  coerceValue(myNormalize, value);
256  break;
257 
258  }
259  }
260 
261  void setParmValue(exint idx, const exint &value)
262  { doSetParmValue(idx, value); }
263  void setParmValue(exint idx, const fpreal &value)
264  { doSetParmValue(idx, value); }
265  void setParmValue(exint idx, const UT_Vector2D &value)
266  { doSetParmValue(idx, value); }
267  void setParmValue(exint idx, const UT_Vector3D &value)
268  { doSetParmValue(idx, value); }
269  void setParmValue(exint idx, const UT_Vector4D &value)
270  { doSetParmValue(idx, value); }
271  void setParmValue(exint idx, const UT_Matrix2D &value)
272  { doSetParmValue(idx, value); }
273  void setParmValue(exint idx, const UT_Matrix3D &value)
274  { doSetParmValue(idx, value); }
275  void setParmValue(exint idx, const UT_Matrix4D &value)
276  { doSetParmValue(idx, value); }
278  { doSetParmValue(idx, value); }
280  { doSetParmValue(idx, value); }
282  { doSetParmValue(idx, value); }
283 
284  virtual exint getNumParms() const
285  {
286  return 12;
287  }
288 
289  virtual const char *getParmName(exint fieldnum) const
290  {
291  switch (fieldnum)
292  {
293  case 0:
294  return "type";
295  case 1:
296  return "method";
297  case 2:
298  return "coords";
299  case 3:
300  return "close";
301  case 4:
302  return "reverse";
303  case 5:
304  return "order";
305  case 6:
306  return "param";
307  case 7:
308  return "tolerance";
309  case 8:
310  return "smooth";
311  case 9:
312  return "csharp";
313  case 10:
314  return "keepgeo";
315  case 11:
316  return "normalize";
317 
318  }
319  return 0;
320  }
321 
322  virtual ParmType getParmType(exint fieldnum) const
323  {
324  switch (fieldnum)
325  {
326  case 0:
327  return PARM_INTEGER;
328  case 1:
329  return PARM_INTEGER;
330  case 2:
331  return PARM_STRING;
332  case 3:
333  return PARM_INTEGER;
334  case 4:
335  return PARM_INTEGER;
336  case 5:
337  return PARM_INTEGER;
338  case 6:
339  return PARM_INTEGER;
340  case 7:
341  return PARM_FLOAT;
342  case 8:
343  return PARM_FLOAT;
344  case 9:
345  return PARM_INTEGER;
346  case 10:
347  return PARM_INTEGER;
348  case 11:
349  return PARM_INTEGER;
350 
351  }
352  return PARM_UNSUPPORTED;
353  }
354 
355  // Boiler plate to load individual types.
356  static void loadData(UT_IStream &is, int64 &v)
357  { is.bread(&v, 1); }
358  static void loadData(UT_IStream &is, bool &v)
359  { int64 iv; is.bread(&iv, 1); v = iv; }
360  static void loadData(UT_IStream &is, fpreal64 &v)
361  { is.bread<fpreal64>(&v, 1); }
362  static void loadData(UT_IStream &is, UT_Vector2D &v)
363  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
364  static void loadData(UT_IStream &is, UT_Vector3D &v)
365  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
366  is.bread<fpreal64>(&v.z(), 1); }
367  static void loadData(UT_IStream &is, UT_Vector4D &v)
368  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
369  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
370  static void loadData(UT_IStream &is, UT_Matrix2D &v)
371  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
372  static void loadData(UT_IStream &is, UT_Matrix3D &v)
373  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
374  static void loadData(UT_IStream &is, UT_Matrix4D &v)
375  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
376  static void loadData(UT_IStream &is, UT_Vector2I &v)
377  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
378  static void loadData(UT_IStream &is, UT_Vector3I &v)
379  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
380  is.bread<int64>(&v.z(), 1); }
381  static void loadData(UT_IStream &is, UT_Vector4I &v)
382  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
383  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
385  { is.bread(v); }
387  { UT_StringHolder rampdata;
388  loadData(is, rampdata);
389  if (rampdata.isstring())
390  {
391  v.reset(new UT_Ramp());
392  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
393  v->load(istr);
394  }
395  else v.reset();
396  }
399  loadData(is, data);
400  if (data.isstring())
401  {
402  // Find the data type.
403  char *colon = UT_StringWrap(data).findChar(':');
404  if (colon)
405  {
406  int typelen = colon - data.buffer();
408  type.strncpy(data.buffer(), typelen);
409  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
410 
411  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
412  }
413  }
414  else v.reset();
415  }
416 
417  static void saveData(std::ostream &os, int64 v)
418  { UTwrite(os, &v); }
419  static void saveData(std::ostream &os, bool v)
420  { int64 iv = v; UTwrite(os, &iv); }
421  static void saveData(std::ostream &os, fpreal64 v)
422  { UTwrite<fpreal64>(os, &v); }
423  static void saveData(std::ostream &os, UT_Vector2D v)
424  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
425  static void saveData(std::ostream &os, UT_Vector3D v)
426  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
427  UTwrite<fpreal64>(os, &v.z()); }
428  static void saveData(std::ostream &os, UT_Vector4D v)
429  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
430  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
431  static void saveData(std::ostream &os, UT_Matrix2D v)
433  static void saveData(std::ostream &os, UT_Matrix3D v)
435  static void saveData(std::ostream &os, UT_Matrix4D v)
437  static void saveData(std::ostream &os, UT_StringHolder s)
438  { UT_StringWrap(s).saveBinary(os); }
439  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
440  { UT_StringHolder result;
441  UT_OStringStream ostr;
442  if (s) s->save(ostr);
443  result = ostr.str();
444  saveData(os, result);
445  }
446  static void saveData(std::ostream &os, PRM_DataItemHandle s)
447  { UT_StringHolder result;
448  UT_OStringStream ostr;
449  if (s)
450  {
451  ostr << s->getDataTypeToken();
452  ostr << ":";
453  s->saveBinary(ostr);
454  }
455  result = ostr.str();
456  saveData(os, result);
457  }
458 
459 
460  void save(std::ostream &os) const
461  {
462  int32 v = version();
463  UTwrite(os, &v);
464  saveData(os, myType);
465  saveData(os, myMethod);
466  saveData(os, myCoords);
467  saveData(os, myClose);
468  saveData(os, myReverse);
469  saveData(os, myOrder);
470  saveData(os, myParam);
471  saveData(os, myTolerance);
472  saveData(os, mySmooth);
473  saveData(os, myCsharp);
474  saveData(os, myKeepgeo);
475  saveData(os, myNormalize);
476 
477  }
478 
479  bool load(UT_IStream &is)
480  {
481  int32 v;
482  is.bread(&v, 1);
483  if (version() != v)
484  {
485  // Fail incompatible versions
486  return false;
487  }
488  loadData(is, myType);
489  loadData(is, myMethod);
490  loadData(is, myCoords);
491  loadData(is, myClose);
492  loadData(is, myReverse);
493  loadData(is, myOrder);
494  loadData(is, myParam);
495  loadData(is, myTolerance);
496  loadData(is, mySmooth);
497  loadData(is, myCsharp);
498  loadData(is, myKeepgeo);
499  loadData(is, myNormalize);
500 
501  return true;
502  }
503 
504  Type getType() const { return Type(myType); }
505  void setType(Type val) { myType = int64(val); }
506  Type opType(const SOP_NodeVerb::CookParms &cookparms) const
507  {
508  SOP_Node *thissop = cookparms.getNode();
509  if (!thissop) return getType();
510  int64 result;
511  OP_Utils::evalOpParm(result, thissop, "type", cookparms.getCookTime(), 0);
512  return Type(result);
513  }
514  Method getMethod() const { return Method(myMethod); }
515  void setMethod(Method val) { myMethod = int64(val); }
516  Method opMethod(const SOP_NodeVerb::CookParms &cookparms) const
517  {
518  SOP_Node *thissop = cookparms.getNode();
519  if (!thissop) return getMethod();
520  int64 result;
521  OP_Utils::evalOpParm(result, thissop, "method", cookparms.getCookTime(), 0);
522  return Method(result);
523  }
524  const UT_StringHolder & getCoords() const { return myCoords; }
525  void setCoords(const UT_StringHolder & val) { myCoords = val; }
527  {
528  SOP_Node *thissop = cookparms.getNode();
529  if (!thissop) return getCoords();
530  UT_StringHolder result;
531  OP_Utils::evalOpParm(result, thissop, "coords", cookparms.getCookTime(), 0);
532  return result;
533  }
534  bool getClose() const { return myClose; }
535  void setClose(bool val) { myClose = val; }
536  bool opClose(const SOP_NodeVerb::CookParms &cookparms) const
537  {
538  SOP_Node *thissop = cookparms.getNode();
539  if (!thissop) return getClose();
540  bool result;
541  OP_Utils::evalOpParm(result, thissop, "close", cookparms.getCookTime(), 0);
542  return result;
543  }
544  bool getReverse() const { return myReverse; }
545  void setReverse(bool val) { myReverse = val; }
546  bool opReverse(const SOP_NodeVerb::CookParms &cookparms) const
547  {
548  SOP_Node *thissop = cookparms.getNode();
549  if (!thissop) return getReverse();
550  bool result;
551  OP_Utils::evalOpParm(result, thissop, "reverse", cookparms.getCookTime(), 0);
552  return result;
553  }
554  int64 getOrder() const { return myOrder; }
555  void setOrder(int64 val) { myOrder = val; }
556  int64 opOrder(const SOP_NodeVerb::CookParms &cookparms) const
557  {
558  SOP_Node *thissop = cookparms.getNode();
559  if (!thissop) return getOrder();
560  int64 result;
561  OP_Utils::evalOpParm(result, thissop, "order", cookparms.getCookTime(), 0);
562  return result;
563  }
564  Param getParam() const { return Param(myParam); }
565  void setParam(Param val) { myParam = int64(val); }
566  Param opParam(const SOP_NodeVerb::CookParms &cookparms) const
567  {
568  SOP_Node *thissop = cookparms.getNode();
569  if (!thissop) return getParam();
570  int64 result;
571  OP_Utils::evalOpParm(result, thissop, "param", cookparms.getCookTime(), 0);
572  return Param(result);
573  }
574  fpreal64 getTolerance() const { return myTolerance; }
575  void setTolerance(fpreal64 val) { myTolerance = val; }
577  {
578  SOP_Node *thissop = cookparms.getNode();
579  if (!thissop) return getTolerance();
580  fpreal64 result;
581  OP_Utils::evalOpParm(result, thissop, "tolerance", cookparms.getCookTime(), 0);
582  return result;
583  }
584  fpreal64 getSmooth() const { return mySmooth; }
585  void setSmooth(fpreal64 val) { mySmooth = val; }
586  fpreal64 opSmooth(const SOP_NodeVerb::CookParms &cookparms) const
587  {
588  SOP_Node *thissop = cookparms.getNode();
589  if (!thissop) return getSmooth();
590  fpreal64 result;
591  OP_Utils::evalOpParm(result, thissop, "smooth", cookparms.getCookTime(), 0);
592  return result;
593  }
594  bool getCsharp() const { return myCsharp; }
595  void setCsharp(bool val) { myCsharp = val; }
596  bool opCsharp(const SOP_NodeVerb::CookParms &cookparms) const
597  {
598  SOP_Node *thissop = cookparms.getNode();
599  if (!thissop) return getCsharp();
600  bool result;
601  OP_Utils::evalOpParm(result, thissop, "csharp", cookparms.getCookTime(), 0);
602  return result;
603  }
604  bool getKeepgeo() const { return myKeepgeo; }
605  void setKeepgeo(bool val) { myKeepgeo = val; }
606  bool opKeepgeo(const SOP_NodeVerb::CookParms &cookparms) const
607  {
608  SOP_Node *thissop = cookparms.getNode();
609  if (!thissop) return getKeepgeo();
610  bool result;
611  OP_Utils::evalOpParm(result, thissop, "keepgeo", cookparms.getCookTime(), 0);
612  return result;
613  }
614  bool getNormalize() const { return myNormalize; }
615  void setNormalize(bool val) { myNormalize = val; }
616  bool opNormalize(const SOP_NodeVerb::CookParms &cookparms) const
617  {
618  SOP_Node *thissop = cookparms.getNode();
619  if (!thissop) return getNormalize();
620  bool result;
621  OP_Utils::evalOpParm(result, thissop, "normalize", cookparms.getCookTime(), 0);
622  return result;
623  }
624 
625 private:
626  int64 myType;
627  int64 myMethod;
628  UT_StringHolder myCoords;
629  bool myClose;
630  bool myReverse;
631  int64 myOrder;
632  int64 myParam;
633  fpreal64 myTolerance;
634  fpreal64 mySmooth;
635  bool myCsharp;
636  bool myKeepgeo;
637  bool myNormalize;
638 
639 };
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:492
T & z(void)
Definition: UT_Vector4.h:372
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)
bool opKeepgeo(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getTime() const
Definition: OP_Context.h:34
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)
virtual ParmType getParmType(exint fieldnum) const
T & x(void)
Definition: UT_Vector2.h:284
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:581
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:585
static void loadData(UT_IStream &is, UT_StringHolder &v)
long long int64
Definition: SYS_Types.h:100
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
int64 exint
Definition: SYS_Types.h:109
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:185
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)
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:28
void setParmValue(exint idx, const UT_Vector4D &value)
T & y(void)
Definition: UT_Vector4.h:370
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
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:583
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:263
void strncpy(const char *src, exint maxlen)
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
const char * buffer() const
Param getParam() const
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:499
T & x(void)
Definition: UT_Vector4.h:368
static void saveData(std::ostream &os, UT_StringHolder s)
void setNormalize(bool val)
T & y(void)
Definition: UT_Vector2.h:286
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:374
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
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)
GLenum src
Definition: glcorearb.h:1792
void getParmValue(exint idx, UT_Vector3D &value) const