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