HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_Revolve.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_RevolveEnums
22 {
23  enum class Surftype
24  {
25  ROWS = 0,
26  COLS,
27  ROWCOL,
28  TRIANGLES,
29  QUADS,
30  ALTTRIANGLES,
31  REVTRIANGLES
32  };
33  enum class Type
34  {
35  CLOSED = 0,
36  OPENARC,
37  CLOSEDARC
38  };
39 }
40 
41 
43 {
44 public:
45  static int version() { return 1; }
46 
48  {
49  myGroup = ""_sh;
50  mySurftype = 4;
51  myOrigin = UT_Vector3D(0,0,0);
52  myDir = UT_Vector3D(0,1,0);
53  myPolys = true;
54  myImperfect = true;
55  myType = 0;
56  myAngle = UT_Vector2D(0,360);
57  myDivs = 10;
58  myOrder = 4;
59  myCap = false;
60 
61  }
62 
63  explicit SOP_RevolveParms(const SOP_RevolveParms &) = default;
64 
65  virtual ~SOP_RevolveParms() {}
66 
67  bool operator==(const SOP_RevolveParms &src) const
68  {
69  if (myGroup != src.myGroup) return false;
70  if (mySurftype != src.mySurftype) return false;
71  if (myOrigin != src.myOrigin) return false;
72  if (myDir != src.myDir) return false;
73  if (myPolys != src.myPolys) return false;
74  if (myImperfect != src.myImperfect) return false;
75  if (myType != src.myType) return false;
76  if (myAngle != src.myAngle) return false;
77  if (myDivs != src.myDivs) return false;
78  if (myOrder != src.myOrder) return false;
79  if (myCap != src.myCap) return false;
80 
81  return true;
82  }
85 
86 
87 
88  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
89  {
90  if (true)
91  OP_Utils::evalOpParm(myGroup, node, "group", time, 0);
92  else myGroup = ""_sh;
93  if (true)
94  OP_Utils::evalOpParm(mySurftype, node, "surftype", time, 0);
95  else mySurftype = 4;
96  if (true)
97  OP_Utils::evalOpParm(myOrigin, node, "origin", time, 0);
98  else myOrigin = UT_Vector3D(0,0,0);
99  if (true)
100  OP_Utils::evalOpParm(myDir, node, "dir", time, 0);
101  else myDir = UT_Vector3D(0,1,0);
102  if (true)
103  OP_Utils::evalOpParm(myPolys, node, "polys", time, 0);
104  else myPolys = true;
105  if (true)
106  OP_Utils::evalOpParm(myImperfect, node, "imperfect", time, 0);
107  else myImperfect = true;
108  if (true)
109  OP_Utils::evalOpParm(myType, node, "type", time, 0);
110  else myType = 0;
111  if (true)
112  OP_Utils::evalOpParm(myAngle, node, "angle", time, 0);
113  else myAngle = UT_Vector2D(0,360);
114  if (true)
115  OP_Utils::evalOpParm(myDivs, node, "divs", time, 0);
116  else myDivs = 10;
117  if (true)
118  OP_Utils::evalOpParm(myOrder, node, "order", time, 0);
119  else myOrder = 4;
120  if (true)
121  OP_Utils::evalOpParm(myCap, node, "cap", time, 0);
122  else myCap = false;
123 
124  }
125 
126 
127  virtual void loadFromOpSubclass(const LoadParms &loadparms)
128  {
129  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
130  }
131 
132 
133  virtual void copyFrom(const SOP_NodeParms *src)
134  {
135  *this = *((const SOP_RevolveParms *)src);
136  }
137 
138  template <typename T>
139  void
140  doGetParmValue(exint idx, T &value) const
141  {
142  switch (idx)
143  {
144  case 0:
145  coerceValue(value, myGroup);
146  break;
147  case 1:
148  coerceValue(value, mySurftype);
149  break;
150  case 2:
151  coerceValue(value, myOrigin);
152  break;
153  case 3:
154  coerceValue(value, myDir);
155  break;
156  case 4:
157  coerceValue(value, myPolys);
158  break;
159  case 5:
160  coerceValue(value, myImperfect);
161  break;
162  case 6:
163  coerceValue(value, myType);
164  break;
165  case 7:
166  coerceValue(value, myAngle);
167  break;
168  case 8:
169  coerceValue(value, myDivs);
170  break;
171  case 9:
172  coerceValue(value, myOrder);
173  break;
174  case 10:
175  coerceValue(value, myCap);
176  break;
177 
178  }
179  }
180 
181  void getParmValue(exint idx, exint &value) const
182  { doGetParmValue(idx, value); }
183  void getParmValue(exint idx, fpreal &value) const
184  { doGetParmValue(idx, value); }
186  { doGetParmValue(idx, value); }
188  { doGetParmValue(idx, value); }
190  { doGetParmValue(idx, value); }
192  { doGetParmValue(idx, value); }
194  { doGetParmValue(idx, value); }
196  { doGetParmValue(idx, value); }
198  { doGetParmValue(idx, value); }
200  { doGetParmValue(idx, value); }
202  { doGetParmValue(idx, value); }
203 
204  template <typename T>
205  void
206  doSetParmValue(exint idx, const T &value)
207  {
208  switch (idx)
209  {
210  case 0:
211  coerceValue(myGroup, value);
212  break;
213  case 1:
214  coerceValue(mySurftype, value);
215  break;
216  case 2:
217  coerceValue(myOrigin, value);
218  break;
219  case 3:
220  coerceValue(myDir, value);
221  break;
222  case 4:
223  coerceValue(myPolys, value);
224  break;
225  case 5:
226  coerceValue(myImperfect, value);
227  break;
228  case 6:
229  coerceValue(myType, value);
230  break;
231  case 7:
232  coerceValue(myAngle, value);
233  break;
234  case 8:
235  coerceValue(myDivs, value);
236  break;
237  case 9:
238  coerceValue(myOrder, value);
239  break;
240  case 10:
241  coerceValue(myCap, value);
242  break;
243 
244  }
245  }
246 
247  void setParmValue(exint idx, const exint &value)
248  { doSetParmValue(idx, value); }
249  void setParmValue(exint idx, const fpreal &value)
250  { doSetParmValue(idx, value); }
251  void setParmValue(exint idx, const UT_Vector2D &value)
252  { doSetParmValue(idx, value); }
253  void setParmValue(exint idx, const UT_Vector3D &value)
254  { doSetParmValue(idx, value); }
255  void setParmValue(exint idx, const UT_Vector4D &value)
256  { doSetParmValue(idx, value); }
257  void setParmValue(exint idx, const UT_Matrix2D &value)
258  { doSetParmValue(idx, value); }
259  void setParmValue(exint idx, const UT_Matrix3D &value)
260  { doSetParmValue(idx, value); }
261  void setParmValue(exint idx, const UT_Matrix4D &value)
262  { doSetParmValue(idx, value); }
264  { doSetParmValue(idx, value); }
266  { doSetParmValue(idx, value); }
268  { doSetParmValue(idx, value); }
269 
270  virtual exint getNumParms() const
271  {
272  return 11;
273  }
274 
275  virtual const char *getParmName(exint fieldnum) const
276  {
277  switch (fieldnum)
278  {
279  case 0:
280  return "group";
281  case 1:
282  return "surftype";
283  case 2:
284  return "origin";
285  case 3:
286  return "dir";
287  case 4:
288  return "polys";
289  case 5:
290  return "imperfect";
291  case 6:
292  return "type";
293  case 7:
294  return "angle";
295  case 8:
296  return "divs";
297  case 9:
298  return "order";
299  case 10:
300  return "cap";
301 
302  }
303  return 0;
304  }
305 
306  virtual ParmType getParmType(exint fieldnum) const
307  {
308  switch (fieldnum)
309  {
310  case 0:
311  return PARM_STRING;
312  case 1:
313  return PARM_INTEGER;
314  case 2:
315  return PARM_VECTOR3;
316  case 3:
317  return PARM_VECTOR3;
318  case 4:
319  return PARM_INTEGER;
320  case 5:
321  return PARM_INTEGER;
322  case 6:
323  return PARM_INTEGER;
324  case 7:
325  return PARM_VECTOR2;
326  case 8:
327  return PARM_INTEGER;
328  case 9:
329  return PARM_INTEGER;
330  case 10:
331  return PARM_INTEGER;
332 
333  }
334  return PARM_UNSUPPORTED;
335  }
336 
337  // Boiler plate to load individual types.
338  static void loadData(UT_IStream &is, int64 &v)
339  { is.bread(&v, 1); }
340  static void loadData(UT_IStream &is, bool &v)
341  { int64 iv; is.bread(&iv, 1); v = iv; }
342  static void loadData(UT_IStream &is, fpreal64 &v)
343  { is.bread<fpreal64>(&v, 1); }
344  static void loadData(UT_IStream &is, UT_Vector2D &v)
345  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
346  static void loadData(UT_IStream &is, UT_Vector3D &v)
347  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
348  is.bread<fpreal64>(&v.z(), 1); }
349  static void loadData(UT_IStream &is, UT_Vector4D &v)
350  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
351  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
352  static void loadData(UT_IStream &is, UT_Matrix2D &v)
353  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
354  static void loadData(UT_IStream &is, UT_Matrix3D &v)
355  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
356  static void loadData(UT_IStream &is, UT_Matrix4D &v)
357  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
358  static void loadData(UT_IStream &is, UT_Vector2I &v)
359  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
360  static void loadData(UT_IStream &is, UT_Vector3I &v)
361  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
362  is.bread<int64>(&v.z(), 1); }
363  static void loadData(UT_IStream &is, UT_Vector4I &v)
364  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
365  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
367  { is.bread(v); }
369  { UT_StringHolder rampdata;
370  loadData(is, rampdata);
371  if (rampdata.isstring())
372  {
373  v.reset(new UT_Ramp());
374  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
375  v->load(istr);
376  }
377  else v.reset();
378  }
381  loadData(is, data);
382  if (data.isstring())
383  {
384  // Find the data type.
385  char *colon = UT_StringWrap(data).findChar(':');
386  if (colon)
387  {
388  int typelen = colon - data.buffer();
390  type.strncpy(data.buffer(), typelen);
391  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
392 
393  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
394  }
395  }
396  else v.reset();
397  }
398 
399  static void saveData(std::ostream &os, int64 v)
400  { UTwrite(os, &v); }
401  static void saveData(std::ostream &os, bool v)
402  { int64 iv = v; UTwrite(os, &iv); }
403  static void saveData(std::ostream &os, fpreal64 v)
404  { UTwrite<fpreal64>(os, &v); }
405  static void saveData(std::ostream &os, UT_Vector2D v)
406  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
407  static void saveData(std::ostream &os, UT_Vector3D v)
408  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
409  UTwrite<fpreal64>(os, &v.z()); }
410  static void saveData(std::ostream &os, UT_Vector4D v)
411  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
412  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
413  static void saveData(std::ostream &os, UT_Matrix2D v)
415  static void saveData(std::ostream &os, UT_Matrix3D v)
417  static void saveData(std::ostream &os, UT_Matrix4D v)
419  static void saveData(std::ostream &os, UT_StringHolder s)
420  { UT_StringWrap(s).saveBinary(os); }
421  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
422  { UT_StringHolder result;
423  UT_OStringStream ostr;
424  if (s) s->save(ostr);
425  result = ostr.str();
426  saveData(os, result);
427  }
428  static void saveData(std::ostream &os, PRM_DataItemHandle s)
429  { UT_StringHolder result;
430  UT_OStringStream ostr;
431  if (s)
432  {
433  ostr << s->getDataTypeToken();
434  ostr << ":";
435  s->saveBinary(ostr);
436  }
437  result = ostr.str();
438  saveData(os, result);
439  }
440 
441 
442  void save(std::ostream &os) const
443  {
444  int32 v = version();
445  UTwrite(os, &v);
446  saveData(os, myGroup);
447  saveData(os, mySurftype);
448  saveData(os, myOrigin);
449  saveData(os, myDir);
450  saveData(os, myPolys);
451  saveData(os, myImperfect);
452  saveData(os, myType);
453  saveData(os, myAngle);
454  saveData(os, myDivs);
455  saveData(os, myOrder);
456  saveData(os, myCap);
457 
458  }
459 
460  bool load(UT_IStream &is)
461  {
462  int32 v;
463  is.bread(&v, 1);
464  if (version() != v)
465  {
466  // Fail incompatible versions
467  return false;
468  }
469  loadData(is, myGroup);
470  loadData(is, mySurftype);
471  loadData(is, myOrigin);
472  loadData(is, myDir);
473  loadData(is, myPolys);
474  loadData(is, myImperfect);
475  loadData(is, myType);
476  loadData(is, myAngle);
477  loadData(is, myDivs);
478  loadData(is, myOrder);
479  loadData(is, myCap);
480 
481  return true;
482  }
483 
484  const UT_StringHolder & getGroup() const { return myGroup; }
485  void setGroup(const UT_StringHolder & val) { myGroup = val; }
487  {
488  SOP_Node *thissop = cookparms.getNode();
489  if (!thissop) return getGroup();
490  UT_StringHolder result;
491  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
492  return result;
493  }
494  Surftype getSurftype() const { return Surftype(mySurftype); }
495  void setSurftype(Surftype val) { mySurftype = int64(val); }
497  {
498  SOP_Node *thissop = cookparms.getNode();
499  if (!thissop) return getSurftype();
500  int64 result;
501  OP_Utils::evalOpParm(result, thissop, "surftype", cookparms.getCookTime(), 0);
502  return Surftype(result);
503  }
504  UT_Vector3D getOrigin() const { return myOrigin; }
505  void setOrigin(UT_Vector3D val) { myOrigin = val; }
507  {
508  SOP_Node *thissop = cookparms.getNode();
509  if (!thissop) return getOrigin();
510  UT_Vector3D result;
511  OP_Utils::evalOpParm(result, thissop, "origin", cookparms.getCookTime(), 0);
512  return result;
513  }
514  UT_Vector3D getDir() const { return myDir; }
515  void setDir(UT_Vector3D val) { myDir = val; }
516  UT_Vector3D opDir(const SOP_NodeVerb::CookParms &cookparms) const
517  {
518  SOP_Node *thissop = cookparms.getNode();
519  if (!thissop) return getDir();
520  UT_Vector3D result;
521  OP_Utils::evalOpParm(result, thissop, "dir", cookparms.getCookTime(), 0);
522  return result;
523  }
524  bool getPolys() const { return myPolys; }
525  void setPolys(bool val) { myPolys = val; }
526  bool opPolys(const SOP_NodeVerb::CookParms &cookparms) const
527  {
528  SOP_Node *thissop = cookparms.getNode();
529  if (!thissop) return getPolys();
530  bool result;
531  OP_Utils::evalOpParm(result, thissop, "polys", cookparms.getCookTime(), 0);
532  return result;
533  }
534  bool getImperfect() const { return myImperfect; }
535  void setImperfect(bool val) { myImperfect = val; }
536  bool opImperfect(const SOP_NodeVerb::CookParms &cookparms) const
537  {
538  SOP_Node *thissop = cookparms.getNode();
539  if (!thissop) return getImperfect();
540  bool result;
541  OP_Utils::evalOpParm(result, thissop, "imperfect", cookparms.getCookTime(), 0);
542  return result;
543  }
544  Type getType() const { return Type(myType); }
545  void setType(Type val) { myType = int64(val); }
546  Type opType(const SOP_NodeVerb::CookParms &cookparms) const
547  {
548  SOP_Node *thissop = cookparms.getNode();
549  if (!thissop) return getType();
550  int64 result;
551  OP_Utils::evalOpParm(result, thissop, "type", cookparms.getCookTime(), 0);
552  return Type(result);
553  }
554  UT_Vector2D getAngle() const { return myAngle; }
555  void setAngle(UT_Vector2D val) { myAngle = val; }
557  {
558  SOP_Node *thissop = cookparms.getNode();
559  if (!thissop) return getAngle();
560  UT_Vector2D result;
561  OP_Utils::evalOpParm(result, thissop, "angle", cookparms.getCookTime(), 0);
562  return result;
563  }
564  int64 getDivs() const { return myDivs; }
565  void setDivs(int64 val) { myDivs = val; }
566  int64 opDivs(const SOP_NodeVerb::CookParms &cookparms) const
567  {
568  SOP_Node *thissop = cookparms.getNode();
569  if (!thissop) return getDivs();
570  int64 result;
571  OP_Utils::evalOpParm(result, thissop, "divs", cookparms.getCookTime(), 0);
572  return result;
573  }
574  int64 getOrder() const { return myOrder; }
575  void setOrder(int64 val) { myOrder = val; }
576  int64 opOrder(const SOP_NodeVerb::CookParms &cookparms) const
577  {
578  SOP_Node *thissop = cookparms.getNode();
579  if (!thissop) return getOrder();
580  int64 result;
581  OP_Utils::evalOpParm(result, thissop, "order", cookparms.getCookTime(), 0);
582  return result;
583  }
584  bool getCap() const { return myCap; }
585  void setCap(bool val) { myCap = val; }
586  bool opCap(const SOP_NodeVerb::CookParms &cookparms) const
587  {
588  SOP_Node *thissop = cookparms.getNode();
589  if (!thissop) return getCap();
590  bool result;
591  OP_Utils::evalOpParm(result, thissop, "cap", cookparms.getCookTime(), 0);
592  return result;
593  }
594 
595 private:
596  UT_StringHolder myGroup;
597  int64 mySurftype;
598  UT_Vector3D myOrigin;
599  UT_Vector3D myDir;
600  bool myPolys;
601  bool myImperfect;
602  int64 myType;
603  UT_Vector2D myAngle;
604  int64 myDivs;
605  int64 myOrder;
606  bool myCap;
607 
608 };
static void loadData(UT_IStream &is, UT_Vector2D &v)
static void saveData(std::ostream &os, UT_StringHolder s)
bool load(UT_IStream &is)
UT_Vector3D getOrigin() const
bool opPolys(const SOP_NodeVerb::CookParms &cookparms) const
int64 opOrder(const SOP_NodeVerb::CookParms &cookparms) const
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:492
static void saveData(std::ostream &os, fpreal64 v)
static void loadData(UT_IStream &is, fpreal64 &v)
void setAngle(UT_Vector2D val)
T & z(void)
Definition: UT_Vector4.h:372
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void getParmValue(exint idx, UT_Vector4D &value) const
UT_Vector3D opDir(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
int myOrder
Definition: GT_CurveEval.h:263
exint bread(int32 *buffer, exint asize=1)
void doGetParmValue(exint idx, T &value) const
bool opCap(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getTime() const
Definition: OP_Context.h:34
UT_Vector2D opAngle(const SOP_NodeVerb::CookParms &cookparms) const
const GLdouble * v
Definition: glcorearb.h:836
UT_Vector2T< fpreal64 > UT_Vector2D
void getParmValue(exint idx, UT_Matrix4D &value) const
void setParmValue(exint idx, const UT_Vector4D &value)
virtual void loadFromOpSubclass(const LoadParms &loadparms)
T & x(void)
Definition: UT_Vector2.h:284
void getParmValue(exint idx, UT_StringHolder &value) const
bool operator==(const SOP_RevolveParms &src) const
An output stream object that owns its own string buffer storage.
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
static void saveData(std::ostream &os, UT_Vector4D v)
void setDir(UT_Vector3D val)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
void setParmValue(exint idx, const PRM_DataItemHandle &value)
UT_Vector3D opOrigin(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void getParmValue(exint idx, UT_Matrix3D &value) const
static void saveData(std::ostream &os, int64 v)
static void loadData(UT_IStream &is, UT_StringHolder &v)
void setParmValue(exint idx, const UT_Matrix4D &value)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
Type getType() const
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
bool getImperfect() const
void setDivs(int64 val)
static void loadData(UT_IStream &is, bool &v)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
long long int64
Definition: SYS_Types.h:100
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
virtual exint getNumParms() const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
void setParmValue(exint idx, const UT_Vector3D &value)
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
SYS_FORCE_INLINE const char * buffer() const
int64 exint
Definition: SYS_Types.h:109
static int version()
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:185
static void loadData(UT_IStream &is, UT_Vector3I &v)
void setOrder(int64 val)
virtual ~SOP_RevolveParms()
void setPolys(bool val)
virtual const char * getParmName(exint fieldnum) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
static void saveData(std::ostream &os, UT_Matrix4D v)
Surftype opSurftype(const SOP_NodeVerb::CookParms &cookparms) const
int64 getDivs() const
void getParmValue(exint idx, PRM_DataItemHandle &value) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
UT_Vector3T< fpreal64 > UT_Vector3D
UT_Vector3D getDir() const
GLboolean * data
Definition: glcorearb.h:130
static void loadData(UT_IStream &is, UT_Vector4D &v)
int int32
Definition: SYS_Types.h:28
T & y(void)
Definition: UT_Vector4.h:370
void setParmValue(exint idx, const fpreal &value)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
static void saveData(std::ostream &os, UT_Matrix3D v)
int64 opDivs(const SOP_NodeVerb::CookParms &cookparms) const
void doSetParmValue(exint idx, const T &value)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
void setParmValue(exint idx, const exint &value)
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
int64 getOrder() const
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector3D &value) const
bool getPolys() 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)
void setParmValue(exint idx, const UT_Matrix3D &value)
void setOrigin(UT_Vector3D val)
static void loadData(UT_IStream &is, UT_Vector3D &v)
static void saveData(std::ostream &os, bool v)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
void setSurftype(Surftype val)
virtual void copyFrom(const SOP_NodeParms *src)
GLuint GLfloat * val
Definition: glcorearb.h:1607
void setType(Type val)
void getParmValue(exint idx, UT_Matrix2D &value) const
#define SOP_API
Definition: SOP_API.h:10
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool getCap() const
const char * buffer() const
void getParmValue(exint idx, fpreal &value) 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
T & y(void)
Definition: UT_Vector2.h:286
void setGroup(const UT_StringHolder &val)
Surftype getSurftype() const
Type opType(const SOP_NodeVerb::CookParms &cookparms) const
bool opImperfect(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector2D v)
GLboolean r
Definition: glcorearb.h:1221
virtual ParmType getParmType(exint fieldnum) const
void setImperfect(bool val)
void getParmValue(exint idx, UT_Vector2D &value) const
T & w(void)
Definition: UT_Vector4.h:374
void setParmValue(exint idx, const UT_Matrix2D &value)
void setParmValue(exint idx, const UT_StringHolder &value)
UT_Vector2D getAngle() const
static void saveData(std::ostream &os, UT_Vector3D v)
void save(std::ostream &os) const
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
void setParmValue(exint idx, const UT_Vector2D &value)
SYS_FORCE_INLINE bool isstring() const
void getParmValue(exint idx, exint &value) const
const UT_StringHolder & getGroup() const
void setCap(bool val)
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
static void saveData(std::ostream &os, UT_Matrix2D v)
static void loadData(UT_IStream &is, int64 &v)
GLenum src
Definition: glcorearb.h:1792