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