HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_Primitive.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_PrimitiveEnums
22 {
23  enum class DoRot
24  {
25  OFF = 0,
26  ON,
27  MATCH
28  };
29  enum class Xord
30  {
31  SRT = 0,
32  STR,
33  RST,
34  RTS,
35  TSR,
36  TRS
37  };
38  enum class Rord
39  {
40  XYZ = 0,
41  XZY,
42  YXZ,
43  YZX,
44  ZXY,
45  ZYX
46  };
47  enum class Doclr
48  {
49  OFF = 0,
50  ON,
51  REMOVE
52  };
53  enum class Doalpha
54  {
55  OFF = 0,
56  ON,
57  REMOVE
58  };
59  enum class Docrease
60  {
61  OFF = 0,
62  ON,
63  REMOVE
64  };
65  enum class Dotexture
66  {
67  OFF = 0,
68  ON,
69  REMOVE
70  };
71  enum class Closeu
72  {
73  SAMECLOSURE = 0,
74  OPEN,
75  CLOSESHARP,
76  CLOSEROUND,
77  UNROLL
78  };
79  enum class Closev
80  {
81  SAMECLOSURE = 0,
82  OPEN,
83  CLOSESHARP,
84  CLOSEROUND,
85  UNROLL
86  };
87  enum class Clampu
88  {
89  SAMECLAMP = 0,
90  CLAMP,
91  UNCLAMP
92  };
93  enum class Clampv
94  {
95  SAMECLAMP = 0,
96  CLAMP,
97  UNCLAMP
98  };
99  enum class Vtxsort
100  {
101  SAMEVERTEX = 0,
102  REVERSE,
103  REVERSEU,
104  REVERSEV,
105  SWAPUV,
106  SHIFT
107  };
108  enum class Prtype
109  {
110  SPHERE = 0,
111  CIRCLE,
112  LINE,
113  TUBE,
114  CAPPED,
115  ROUNDED
116  };
117  enum class Volvis
118  {
119  SMOKE = 0,
120  RAINBOW,
121  ISO,
122  INVISIBLE,
124  };
125  enum class Volborder
126  {
127  CONSTANT = 0,
128  REPEAT,
129  STREAK,
130  SDF
131  };
132 }
133 
134 
136 {
137 public:
138  static int version() { return 1; }
139 
141  {
142  myGroup = ""_sh;
143  myDoXform = false;
144  myDoRot = 0;
145  myXord = 0;
146  myRord = 0;
147  myT = UT_Vector3D(0,0,0);
148  myR = UT_Vector3D(0,0,0);
149  myS = UT_Vector3D(1,1,1);
150  myShear = UT_Vector3D(0,0,0);
151  myP = UT_Vector3D(0,0,0);
152  myPr = UT_Vector3D(0,0,0);
153  myLookatpath = ""_sh;
154  myUpvector = UT_Vector3D(0,0,0);
155  myXformattribs = "N"_sh;
156  myDoclr = 0;
157  myDiff = UT_Vector3D(0,0,0);
158  myDoalpha = 0;
159  myAlpha = 0;
160  myDocrease = 0;
161  myCrease = 0;
162  myDotexture = 0;
163  myTexture = ""_sh;
164  myCloseu = 0;
165  myClosev = 0;
166  myClampu = 0;
167  myClampv = 0;
168  myVtxsort = 0;
169  myVtxuoff = 0;
170  myVtxvoff = 0;
171  myDoweight = false;
172  myMetaweight = 0;
173  myDoprender = false;
174  myPrtype = 0;
175  myPrsize = 0.05;
176  myPrblur = 0;
177  myDovolvis = false;
178  myVolvis = 0;
179  myVolvisiso = 0;
180  myVolvisdensity = 1;
181  myDotaper = false;
182  myTaper = UT_Vector2D(1,1);
183  myDovolume = false;
184  myVolborder = 0;
185  myVolborderval = 0;
186  myDovoltol = false;
187  myVoltol = 0;
188  myDovdbclass = false;
189  myVdbclass = 0;
190  myDovdbcreator = false;
191  myVdbcreator = ""_sh;
192  myDovdbtransform = false;
193  myVdbtransform = false;
194  myDovdbvectype = false;
195  myVdbvectype = 0;
196  myDovdbhalf = false;
197  myVdbhalf = false;
198  myTemplategrp = ""_sh;
199  myPshapeu = false;
200  myPshapev = false;
201 
202  }
203 
204  explicit SOP_PrimitiveParms(const SOP_PrimitiveParms &) = default;
205 
206  virtual ~SOP_PrimitiveParms() {}
207 
208  bool operator==(const SOP_PrimitiveParms &src) const
209  {
210  if (myGroup != src.myGroup) return false;
211  if (myDoXform != src.myDoXform) return false;
212  if (myDoRot != src.myDoRot) return false;
213  if (myXord != src.myXord) return false;
214  if (myRord != src.myRord) return false;
215  if (myT != src.myT) return false;
216  if (myR != src.myR) return false;
217  if (myS != src.myS) return false;
218  if (myShear != src.myShear) return false;
219  if (myP != src.myP) return false;
220  if (myPr != src.myPr) return false;
221  if (myLookatpath != src.myLookatpath) return false;
222  if (myUpvector != src.myUpvector) return false;
223  if (myXformattribs != src.myXformattribs) return false;
224  if (myDoclr != src.myDoclr) return false;
225  if (myDiff != src.myDiff) return false;
226  if (myDoalpha != src.myDoalpha) return false;
227  if (myAlpha != src.myAlpha) return false;
228  if (myDocrease != src.myDocrease) return false;
229  if (myCrease != src.myCrease) return false;
230  if (myDotexture != src.myDotexture) return false;
231  if (myTexture != src.myTexture) return false;
232  if (myCloseu != src.myCloseu) return false;
233  if (myClosev != src.myClosev) return false;
234  if (myClampu != src.myClampu) return false;
235  if (myClampv != src.myClampv) return false;
236  if (myVtxsort != src.myVtxsort) return false;
237  if (myVtxuoff != src.myVtxuoff) return false;
238  if (myVtxvoff != src.myVtxvoff) return false;
239  if (myDoweight != src.myDoweight) return false;
240  if (myMetaweight != src.myMetaweight) return false;
241  if (myDoprender != src.myDoprender) return false;
242  if (myPrtype != src.myPrtype) return false;
243  if (myPrsize != src.myPrsize) return false;
244  if (myPrblur != src.myPrblur) return false;
245  if (myDovolvis != src.myDovolvis) return false;
246  if (myVolvis != src.myVolvis) return false;
247  if (myVolvisiso != src.myVolvisiso) return false;
248  if (myVolvisdensity != src.myVolvisdensity) return false;
249  if (myDotaper != src.myDotaper) return false;
250  if (myTaper != src.myTaper) return false;
251  if (myDovolume != src.myDovolume) return false;
252  if (myVolborder != src.myVolborder) return false;
253  if (myVolborderval != src.myVolborderval) return false;
254  if (myDovoltol != src.myDovoltol) return false;
255  if (myVoltol != src.myVoltol) return false;
256  if (myDovdbclass != src.myDovdbclass) return false;
257  if (myVdbclass != src.myVdbclass) return false;
258  if (myDovdbcreator != src.myDovdbcreator) return false;
259  if (myVdbcreator != src.myVdbcreator) return false;
260  if (myDovdbtransform != src.myDovdbtransform) return false;
261  if (myVdbtransform != src.myVdbtransform) return false;
262  if (myDovdbvectype != src.myDovdbvectype) return false;
263  if (myVdbvectype != src.myVdbvectype) return false;
264  if (myDovdbhalf != src.myDovdbhalf) return false;
265  if (myVdbhalf != src.myVdbhalf) return false;
266  if (myTemplategrp != src.myTemplategrp) return false;
267  if (myPshapeu != src.myPshapeu) return false;
268  if (myPshapev != src.myPshapev) return false;
269 
270  return true;
271  }
272  bool operator!=(const SOP_PrimitiveParms &src) const
273  {
274  return !operator==(src);
275  }
291 
292 
293 
294  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
295  {
296  if (true)
297  OP_Utils::evalOpParm(myGroup, node, "group", time, 0);
298  else myGroup = ""_sh;
299  if (true)
300  OP_Utils::evalOpParm(myDoXform, node, "doxform", time, 0);
301  else myDoXform = false;
302  if (true && ( (!((((node->getInput(1)!=0)==0))||((getDoXform()==0)))) ) )
303  OP_Utils::evalOpParm(myDoRot, node, "dorot", time, 0);
304  else myDoRot = 0;
305  if (true && ( (!(((getDoXform()==0)))) ) )
306  OP_Utils::evalOpParm(myXord, node, "xOrd", time, 0);
307  else myXord = 0;
308  if (true && ( (!(((getDoXform()==0)))) ) )
309  OP_Utils::evalOpParm(myRord, node, "rOrd", time, 0);
310  else myRord = 0;
311  if (true && ( (!(((getDoXform()==0)))) ) )
312  OP_Utils::evalOpParm(myT, node, "t", time, 0);
313  else myT = UT_Vector3D(0,0,0);
314  if (true && ( (!(((getDoXform()==0)))) ) )
315  OP_Utils::evalOpParm(myR, node, "r", time, 0);
316  else myR = UT_Vector3D(0,0,0);
317  if (true && ( (!(((getDoXform()==0)))) ) )
318  OP_Utils::evalOpParm(myS, node, "s", time, 0);
319  else myS = UT_Vector3D(1,1,1);
320  if (true && ( (!(((getDoXform()==0)))) ) )
321  OP_Utils::evalOpParm(myShear, node, "shear", time, 0);
322  else myShear = UT_Vector3D(0,0,0);
323  if (true && ( (!(((getDoXform()==0)))) ) )
324  OP_Utils::evalOpParm(myP, node, "p", time, 0);
325  else myP = UT_Vector3D(0,0,0);
326  if (true && ( (!(((getDoXform()==0)))) ) )
327  OP_Utils::evalOpParm(myPr, node, "pr", time, 0);
328  else myPr = UT_Vector3D(0,0,0);
329  if (true && ( (!(((getDoXform()==0)))) ) )
330  OP_Utils::evalOpParm(myLookatpath, node, "lookatpath", time, 0);
331  else myLookatpath = ""_sh;
332  if (true && ( (!(((getDoXform()==0))||((getLookatpath()=="")))) ) )
333  OP_Utils::evalOpParm(myUpvector, node, "upvector", time, 0);
334  else myUpvector = UT_Vector3D(0,0,0);
335  if (true && ( (!(((getDoXform()==0)))) ) )
336  OP_Utils::evalOpParm(myXformattribs, node, "xformattribs", time, 0);
337  else myXformattribs = "N"_sh;
338  if (true)
339  OP_Utils::evalOpParm(myDoclr, node, "doclr", time, 0);
340  else myDoclr = 0;
341  if (true && ( (!(((int64(getDoclr())!=1)))) ) )
342  OP_Utils::evalOpParm(myDiff, node, "diff", time, 0);
343  else myDiff = UT_Vector3D(0,0,0);
344  if (true)
345  OP_Utils::evalOpParm(myDoalpha, node, "doalpha", time, 0);
346  else myDoalpha = 0;
347  if (true && ( (!(((int64(getDoalpha())!=1)))) ) )
348  OP_Utils::evalOpParm(myAlpha, node, "alpha", time, 0);
349  else myAlpha = 0;
350  if (true)
351  OP_Utils::evalOpParm(myDocrease, node, "docrease", time, 0);
352  else myDocrease = 0;
353  if (true && ( (!(((int64(getDocrease())!=1)))) ) )
354  OP_Utils::evalOpParm(myCrease, node, "crease", time, 0);
355  else myCrease = 0;
356  if (true)
357  OP_Utils::evalOpParm(myDotexture, node, "dotexture", time, 0);
358  else myDotexture = 0;
359  if (true && ( (!(((int64(getDotexture())!=1)))) ) )
360  OP_Utils::evalOpParm(myTexture, node, "texture", time, 0);
361  else myTexture = ""_sh;
362  if (true)
363  OP_Utils::evalOpParm(myCloseu, node, "closeu", time, 0);
364  else myCloseu = 0;
365  if (true)
366  OP_Utils::evalOpParm(myClosev, node, "closev", time, 0);
367  else myClosev = 0;
368  if (true)
369  OP_Utils::evalOpParm(myClampu, node, "clampu", time, 0);
370  else myClampu = 0;
371  if (true)
372  OP_Utils::evalOpParm(myClampv, node, "clampv", time, 0);
373  else myClampv = 0;
374  if (true)
375  OP_Utils::evalOpParm(myVtxsort, node, "vtxsort", time, 0);
376  else myVtxsort = 0;
377  if (true && ( (!(((int64(getVtxsort())!=5)))) ) )
378  OP_Utils::evalOpParm(myVtxuoff, node, "vtxuoff", time, 0);
379  else myVtxuoff = 0;
380  if (true && ( (!(((int64(getVtxsort())!=5)))) ) )
381  OP_Utils::evalOpParm(myVtxvoff, node, "vtxvoff", time, 0);
382  else myVtxvoff = 0;
383  if (true)
384  OP_Utils::evalOpParm(myDoweight, node, "doweight", time, 0);
385  else myDoweight = false;
386  if (true && ( (!(((getDoweight()==0)))) ) )
387  OP_Utils::evalOpParm(myMetaweight, node, "metaweight", time, 0);
388  else myMetaweight = 0;
389  if (true)
390  OP_Utils::evalOpParm(myDoprender, node, "doprender", time, 0);
391  else myDoprender = false;
392  if (true && ( (!(((getDoprender()==0)))) ) )
393  OP_Utils::evalOpParm(myPrtype, node, "prtype", time, 0);
394  else myPrtype = 0;
395  if (true && ( (!(((getDoprender()==0)))) ) )
396  OP_Utils::evalOpParm(myPrsize, node, "prsize", time, 0);
397  else myPrsize = 0.05;
398  if (true && ( (!(((getDoprender()==0)))) ) )
399  OP_Utils::evalOpParm(myPrblur, node, "prblur", time, 0);
400  else myPrblur = 0;
401  if (true)
402  OP_Utils::evalOpParm(myDovolvis, node, "dovolvis", time, 0);
403  else myDovolvis = false;
404  if (true && ( (!(((getDovolvis()==0)))) ) )
405  OP_Utils::evalOpParm(myVolvis, node, "volvis", time, 0);
406  else myVolvis = 0;
407  if (true && ( (!(((getDovolvis()==0)))) ) )
408  OP_Utils::evalOpParm(myVolvisiso, node, "volvisiso", time, 0);
409  else myVolvisiso = 0;
410  if (true && ( (!(((getDovolvis()==0)))) ) )
411  OP_Utils::evalOpParm(myVolvisdensity, node, "volvisdensity", time, 0);
412  else myVolvisdensity = 1;
413  if (true)
414  OP_Utils::evalOpParm(myDotaper, node, "dotaper", time, 0);
415  else myDotaper = false;
416  if (true && ( (!(((getDotaper()==0)))) ) )
417  OP_Utils::evalOpParm(myTaper, node, "taper", time, 0);
418  else myTaper = UT_Vector2D(1,1);
419  if (true)
420  OP_Utils::evalOpParm(myDovolume, node, "dovolume", time, 0);
421  else myDovolume = false;
422  if (true && ( (!(((getDovolume()==0)))) ) )
423  OP_Utils::evalOpParm(myVolborder, node, "volborder", time, 0);
424  else myVolborder = 0;
425  if (true && ( (!(((getDovolume()==0)))) ) )
426  OP_Utils::evalOpParm(myVolborderval, node, "volborderval", time, 0);
427  else myVolborderval = 0;
428  if (true)
429  OP_Utils::evalOpParm(myDovoltol, node, "dovoltol", time, 0);
430  else myDovoltol = false;
431  if (true && ( (!(((getDovoltol()==0)))) ) )
432  OP_Utils::evalOpParm(myVoltol, node, "voltol", time, 0);
433  else myVoltol = 0;
434  if (true)
435  OP_Utils::evalOpParm(myDovdbclass, node, "dovdbclass", time, 0);
436  else myDovdbclass = false;
437  if (true && ( (!(((getDovdbclass()==0)))) ) )
438  OP_Utils::evalOpParm(myVdbclass, node, "vdbclass", time, 0);
439  else myVdbclass = 0;
440  if (true)
441  OP_Utils::evalOpParm(myDovdbcreator, node, "dovdbcreator", time, 0);
442  else myDovdbcreator = false;
443  if (true && ( (!(((getDovdbcreator()==0)))) ) )
444  OP_Utils::evalOpParm(myVdbcreator, node, "vdbcreator", time, 0);
445  else myVdbcreator = ""_sh;
446  if (true)
447  OP_Utils::evalOpParm(myDovdbtransform, node, "dovdbtransform", time, 0);
448  else myDovdbtransform = false;
449  if (true && ( (!(((getDovdbtransform()==0)))) ) )
450  OP_Utils::evalOpParm(myVdbtransform, node, "vdbtransform", time, 0);
451  else myVdbtransform = false;
452  if (true)
453  OP_Utils::evalOpParm(myDovdbvectype, node, "dovdbvectype", time, 0);
454  else myDovdbvectype = false;
455  if (true && ( (!(((getDovdbvectype()==0)))) ) )
456  OP_Utils::evalOpParm(myVdbvectype, node, "vdbvectype", time, 0);
457  else myVdbvectype = 0;
458  if (true)
459  OP_Utils::evalOpParm(myDovdbhalf, node, "dovdbhalf", time, 0);
460  else myDovdbhalf = false;
461  if (true && ( (!(((getDovdbhalf()==0)))) ) )
462  OP_Utils::evalOpParm(myVdbhalf, node, "vdbhalf", time, 0);
463  else myVdbhalf = false;
464  if (true && ( (!((((node->getInput(1)!=0)==0))||((getDoXform()==0)))) ) )
465  OP_Utils::evalOpParm(myTemplategrp, node, "templateGrp", time, 0);
466  else myTemplategrp = ""_sh;
467  if (true && ( (!(((int64(getCloseu())==0)&&(int64(getClampu())==0)))) ) )
468  OP_Utils::evalOpParm(myPshapeu, node, "pshapeu", time, 0);
469  else myPshapeu = false;
470  if (true && ( (!(((int64(getClosev())==0)&&(int64(getClampv())==0)))) ) )
471  OP_Utils::evalOpParm(myPshapev, node, "pshapev", time, 0);
472  else myPshapev = false;
473 
474  }
475 
476 
477  virtual void loadFromOpSubclass(const LoadParms &loadparms)
478  {
479  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
480  }
481 
482 
483  virtual void copyFrom(const SOP_NodeParms *src)
484  {
485  *this = *((const SOP_PrimitiveParms *)src);
486  }
487 
488  template <typename T>
489  void
490  doGetParmValue(exint idx, T &value) const
491  {
492  switch (idx)
493  {
494  case 0:
495  coerceValue(value, myGroup);
496  break;
497  case 1:
498  coerceValue(value, myDoXform);
499  break;
500  case 2:
501  coerceValue(value, myDoRot);
502  break;
503  case 3:
504  coerceValue(value, myXord);
505  break;
506  case 4:
507  coerceValue(value, myRord);
508  break;
509  case 5:
510  coerceValue(value, myT);
511  break;
512  case 6:
513  coerceValue(value, myR);
514  break;
515  case 7:
516  coerceValue(value, myS);
517  break;
518  case 8:
519  coerceValue(value, myShear);
520  break;
521  case 9:
522  coerceValue(value, myP);
523  break;
524  case 10:
525  coerceValue(value, myPr);
526  break;
527  case 11:
528  coerceValue(value, myLookatpath);
529  break;
530  case 12:
531  coerceValue(value, myUpvector);
532  break;
533  case 13:
534  coerceValue(value, myXformattribs);
535  break;
536  case 14:
537  coerceValue(value, myDoclr);
538  break;
539  case 15:
540  coerceValue(value, myDiff);
541  break;
542  case 16:
543  coerceValue(value, myDoalpha);
544  break;
545  case 17:
546  coerceValue(value, myAlpha);
547  break;
548  case 18:
549  coerceValue(value, myDocrease);
550  break;
551  case 19:
552  coerceValue(value, myCrease);
553  break;
554  case 20:
555  coerceValue(value, myDotexture);
556  break;
557  case 21:
558  coerceValue(value, myTexture);
559  break;
560  case 22:
561  coerceValue(value, myCloseu);
562  break;
563  case 23:
564  coerceValue(value, myClosev);
565  break;
566  case 24:
567  coerceValue(value, myClampu);
568  break;
569  case 25:
570  coerceValue(value, myClampv);
571  break;
572  case 26:
573  coerceValue(value, myVtxsort);
574  break;
575  case 27:
576  coerceValue(value, myVtxuoff);
577  break;
578  case 28:
579  coerceValue(value, myVtxvoff);
580  break;
581  case 29:
582  coerceValue(value, myDoweight);
583  break;
584  case 30:
585  coerceValue(value, myMetaweight);
586  break;
587  case 31:
588  coerceValue(value, myDoprender);
589  break;
590  case 32:
591  coerceValue(value, myPrtype);
592  break;
593  case 33:
594  coerceValue(value, myPrsize);
595  break;
596  case 34:
597  coerceValue(value, myPrblur);
598  break;
599  case 35:
600  coerceValue(value, myDovolvis);
601  break;
602  case 36:
603  coerceValue(value, myVolvis);
604  break;
605  case 37:
606  coerceValue(value, myVolvisiso);
607  break;
608  case 38:
609  coerceValue(value, myVolvisdensity);
610  break;
611  case 39:
612  coerceValue(value, myDotaper);
613  break;
614  case 40:
615  coerceValue(value, myTaper);
616  break;
617  case 41:
618  coerceValue(value, myDovolume);
619  break;
620  case 42:
621  coerceValue(value, myVolborder);
622  break;
623  case 43:
624  coerceValue(value, myVolborderval);
625  break;
626  case 44:
627  coerceValue(value, myDovoltol);
628  break;
629  case 45:
630  coerceValue(value, myVoltol);
631  break;
632  case 46:
633  coerceValue(value, myDovdbclass);
634  break;
635  case 47:
636  coerceValue(value, myVdbclass);
637  break;
638  case 48:
639  coerceValue(value, myDovdbcreator);
640  break;
641  case 49:
642  coerceValue(value, myVdbcreator);
643  break;
644  case 50:
645  coerceValue(value, myDovdbtransform);
646  break;
647  case 51:
648  coerceValue(value, myVdbtransform);
649  break;
650  case 52:
651  coerceValue(value, myDovdbvectype);
652  break;
653  case 53:
654  coerceValue(value, myVdbvectype);
655  break;
656  case 54:
657  coerceValue(value, myDovdbhalf);
658  break;
659  case 55:
660  coerceValue(value, myVdbhalf);
661  break;
662  case 56:
663  coerceValue(value, myTemplategrp);
664  break;
665  case 57:
666  coerceValue(value, myPshapeu);
667  break;
668  case 58:
669  coerceValue(value, myPshapev);
670  break;
671 
672  }
673  }
674 
675  void getParmValue(exint idx, exint &value) const
676  { doGetParmValue(idx, value); }
677  void getParmValue(exint idx, fpreal &value) const
678  { doGetParmValue(idx, value); }
680  { doGetParmValue(idx, value); }
682  { doGetParmValue(idx, value); }
684  { doGetParmValue(idx, value); }
686  { doGetParmValue(idx, value); }
688  { doGetParmValue(idx, value); }
690  { doGetParmValue(idx, value); }
692  { doGetParmValue(idx, value); }
694  { doGetParmValue(idx, value); }
696  { doGetParmValue(idx, value); }
697 
698  template <typename T>
699  void
700  doSetParmValue(exint idx, const T &value)
701  {
702  switch (idx)
703  {
704  case 0:
705  coerceValue(myGroup, value);
706  break;
707  case 1:
708  coerceValue(myDoXform, value);
709  break;
710  case 2:
711  coerceValue(myDoRot, value);
712  break;
713  case 3:
714  coerceValue(myXord, value);
715  break;
716  case 4:
717  coerceValue(myRord, value);
718  break;
719  case 5:
720  coerceValue(myT, value);
721  break;
722  case 6:
723  coerceValue(myR, value);
724  break;
725  case 7:
726  coerceValue(myS, value);
727  break;
728  case 8:
729  coerceValue(myShear, value);
730  break;
731  case 9:
732  coerceValue(myP, value);
733  break;
734  case 10:
735  coerceValue(myPr, value);
736  break;
737  case 11:
738  coerceValue(myLookatpath, value);
739  break;
740  case 12:
741  coerceValue(myUpvector, value);
742  break;
743  case 13:
744  coerceValue(myXformattribs, value);
745  break;
746  case 14:
747  coerceValue(myDoclr, value);
748  break;
749  case 15:
750  coerceValue(myDiff, value);
751  break;
752  case 16:
753  coerceValue(myDoalpha, value);
754  break;
755  case 17:
756  coerceValue(myAlpha, value);
757  break;
758  case 18:
759  coerceValue(myDocrease, value);
760  break;
761  case 19:
762  coerceValue(myCrease, value);
763  break;
764  case 20:
765  coerceValue(myDotexture, value);
766  break;
767  case 21:
768  coerceValue(myTexture, value);
769  break;
770  case 22:
771  coerceValue(myCloseu, value);
772  break;
773  case 23:
774  coerceValue(myClosev, value);
775  break;
776  case 24:
777  coerceValue(myClampu, value);
778  break;
779  case 25:
780  coerceValue(myClampv, value);
781  break;
782  case 26:
783  coerceValue(myVtxsort, value);
784  break;
785  case 27:
786  coerceValue(myVtxuoff, value);
787  break;
788  case 28:
789  coerceValue(myVtxvoff, value);
790  break;
791  case 29:
792  coerceValue(myDoweight, value);
793  break;
794  case 30:
795  coerceValue(myMetaweight, value);
796  break;
797  case 31:
798  coerceValue(myDoprender, value);
799  break;
800  case 32:
801  coerceValue(myPrtype, value);
802  break;
803  case 33:
804  coerceValue(myPrsize, value);
805  break;
806  case 34:
807  coerceValue(myPrblur, value);
808  break;
809  case 35:
810  coerceValue(myDovolvis, value);
811  break;
812  case 36:
813  coerceValue(myVolvis, value);
814  break;
815  case 37:
816  coerceValue(myVolvisiso, value);
817  break;
818  case 38:
819  coerceValue(myVolvisdensity, value);
820  break;
821  case 39:
822  coerceValue(myDotaper, value);
823  break;
824  case 40:
825  coerceValue(myTaper, value);
826  break;
827  case 41:
828  coerceValue(myDovolume, value);
829  break;
830  case 42:
831  coerceValue(myVolborder, value);
832  break;
833  case 43:
834  coerceValue(myVolborderval, value);
835  break;
836  case 44:
837  coerceValue(myDovoltol, value);
838  break;
839  case 45:
840  coerceValue(myVoltol, value);
841  break;
842  case 46:
843  coerceValue(myDovdbclass, value);
844  break;
845  case 47:
846  coerceValue(myVdbclass, value);
847  break;
848  case 48:
849  coerceValue(myDovdbcreator, value);
850  break;
851  case 49:
852  coerceValue(myVdbcreator, value);
853  break;
854  case 50:
855  coerceValue(myDovdbtransform, value);
856  break;
857  case 51:
858  coerceValue(myVdbtransform, value);
859  break;
860  case 52:
861  coerceValue(myDovdbvectype, value);
862  break;
863  case 53:
864  coerceValue(myVdbvectype, value);
865  break;
866  case 54:
867  coerceValue(myDovdbhalf, value);
868  break;
869  case 55:
870  coerceValue(myVdbhalf, value);
871  break;
872  case 56:
873  coerceValue(myTemplategrp, value);
874  break;
875  case 57:
876  coerceValue(myPshapeu, value);
877  break;
878  case 58:
879  coerceValue(myPshapev, value);
880  break;
881 
882  }
883  }
884 
885  void setParmValue(exint idx, const exint &value)
886  { doSetParmValue(idx, value); }
887  void setParmValue(exint idx, const fpreal &value)
888  { doSetParmValue(idx, value); }
889  void setParmValue(exint idx, const UT_Vector2D &value)
890  { doSetParmValue(idx, value); }
891  void setParmValue(exint idx, const UT_Vector3D &value)
892  { doSetParmValue(idx, value); }
893  void setParmValue(exint idx, const UT_Vector4D &value)
894  { doSetParmValue(idx, value); }
895  void setParmValue(exint idx, const UT_Matrix2D &value)
896  { doSetParmValue(idx, value); }
897  void setParmValue(exint idx, const UT_Matrix3D &value)
898  { doSetParmValue(idx, value); }
899  void setParmValue(exint idx, const UT_Matrix4D &value)
900  { doSetParmValue(idx, value); }
902  { doSetParmValue(idx, value); }
904  { doSetParmValue(idx, value); }
906  { doSetParmValue(idx, value); }
907 
908  virtual exint getNumParms() const
909  {
910  return 59;
911  }
912 
913  virtual const char *getParmName(exint fieldnum) const
914  {
915  switch (fieldnum)
916  {
917  case 0:
918  return "group";
919  case 1:
920  return "doxform";
921  case 2:
922  return "dorot";
923  case 3:
924  return "xOrd";
925  case 4:
926  return "rOrd";
927  case 5:
928  return "t";
929  case 6:
930  return "r";
931  case 7:
932  return "s";
933  case 8:
934  return "shear";
935  case 9:
936  return "p";
937  case 10:
938  return "pr";
939  case 11:
940  return "lookatpath";
941  case 12:
942  return "upvector";
943  case 13:
944  return "xformattribs";
945  case 14:
946  return "doclr";
947  case 15:
948  return "diff";
949  case 16:
950  return "doalpha";
951  case 17:
952  return "alpha";
953  case 18:
954  return "docrease";
955  case 19:
956  return "crease";
957  case 20:
958  return "dotexture";
959  case 21:
960  return "texture";
961  case 22:
962  return "closeu";
963  case 23:
964  return "closev";
965  case 24:
966  return "clampu";
967  case 25:
968  return "clampv";
969  case 26:
970  return "vtxsort";
971  case 27:
972  return "vtxuoff";
973  case 28:
974  return "vtxvoff";
975  case 29:
976  return "doweight";
977  case 30:
978  return "metaweight";
979  case 31:
980  return "doprender";
981  case 32:
982  return "prtype";
983  case 33:
984  return "prsize";
985  case 34:
986  return "prblur";
987  case 35:
988  return "dovolvis";
989  case 36:
990  return "volvis";
991  case 37:
992  return "volvisiso";
993  case 38:
994  return "volvisdensity";
995  case 39:
996  return "dotaper";
997  case 40:
998  return "taper";
999  case 41:
1000  return "dovolume";
1001  case 42:
1002  return "volborder";
1003  case 43:
1004  return "volborderval";
1005  case 44:
1006  return "dovoltol";
1007  case 45:
1008  return "voltol";
1009  case 46:
1010  return "dovdbclass";
1011  case 47:
1012  return "vdbclass";
1013  case 48:
1014  return "dovdbcreator";
1015  case 49:
1016  return "vdbcreator";
1017  case 50:
1018  return "dovdbtransform";
1019  case 51:
1020  return "vdbtransform";
1021  case 52:
1022  return "dovdbvectype";
1023  case 53:
1024  return "vdbvectype";
1025  case 54:
1026  return "dovdbhalf";
1027  case 55:
1028  return "vdbhalf";
1029  case 56:
1030  return "templateGrp";
1031  case 57:
1032  return "pshapeu";
1033  case 58:
1034  return "pshapev";
1035 
1036  }
1037  return 0;
1038  }
1039 
1040  virtual ParmType getParmType(exint fieldnum) const
1041  {
1042  switch (fieldnum)
1043  {
1044  case 0:
1045  return PARM_STRING;
1046  case 1:
1047  return PARM_INTEGER;
1048  case 2:
1049  return PARM_INTEGER;
1050  case 3:
1051  return PARM_INTEGER;
1052  case 4:
1053  return PARM_INTEGER;
1054  case 5:
1055  return PARM_VECTOR3;
1056  case 6:
1057  return PARM_VECTOR3;
1058  case 7:
1059  return PARM_VECTOR3;
1060  case 8:
1061  return PARM_VECTOR3;
1062  case 9:
1063  return PARM_VECTOR3;
1064  case 10:
1065  return PARM_VECTOR3;
1066  case 11:
1067  return PARM_STRING;
1068  case 12:
1069  return PARM_VECTOR3;
1070  case 13:
1071  return PARM_STRING;
1072  case 14:
1073  return PARM_INTEGER;
1074  case 15:
1075  return PARM_VECTOR3;
1076  case 16:
1077  return PARM_INTEGER;
1078  case 17:
1079  return PARM_FLOAT;
1080  case 18:
1081  return PARM_INTEGER;
1082  case 19:
1083  return PARM_FLOAT;
1084  case 20:
1085  return PARM_INTEGER;
1086  case 21:
1087  return PARM_STRING;
1088  case 22:
1089  return PARM_INTEGER;
1090  case 23:
1091  return PARM_INTEGER;
1092  case 24:
1093  return PARM_INTEGER;
1094  case 25:
1095  return PARM_INTEGER;
1096  case 26:
1097  return PARM_INTEGER;
1098  case 27:
1099  return PARM_INTEGER;
1100  case 28:
1101  return PARM_INTEGER;
1102  case 29:
1103  return PARM_INTEGER;
1104  case 30:
1105  return PARM_FLOAT;
1106  case 31:
1107  return PARM_INTEGER;
1108  case 32:
1109  return PARM_INTEGER;
1110  case 33:
1111  return PARM_FLOAT;
1112  case 34:
1113  return PARM_FLOAT;
1114  case 35:
1115  return PARM_INTEGER;
1116  case 36:
1117  return PARM_INTEGER;
1118  case 37:
1119  return PARM_FLOAT;
1120  case 38:
1121  return PARM_FLOAT;
1122  case 39:
1123  return PARM_INTEGER;
1124  case 40:
1125  return PARM_VECTOR2;
1126  case 41:
1127  return PARM_INTEGER;
1128  case 42:
1129  return PARM_INTEGER;
1130  case 43:
1131  return PARM_FLOAT;
1132  case 44:
1133  return PARM_INTEGER;
1134  case 45:
1135  return PARM_FLOAT;
1136  case 46:
1137  return PARM_INTEGER;
1138  case 47:
1139  return PARM_INTEGER;
1140  case 48:
1141  return PARM_INTEGER;
1142  case 49:
1143  return PARM_STRING;
1144  case 50:
1145  return PARM_INTEGER;
1146  case 51:
1147  return PARM_INTEGER;
1148  case 52:
1149  return PARM_INTEGER;
1150  case 53:
1151  return PARM_INTEGER;
1152  case 54:
1153  return PARM_INTEGER;
1154  case 55:
1155  return PARM_INTEGER;
1156  case 56:
1157  return PARM_STRING;
1158  case 57:
1159  return PARM_INTEGER;
1160  case 58:
1161  return PARM_INTEGER;
1162 
1163  }
1164  return PARM_UNSUPPORTED;
1165  }
1166 
1167  // Boiler plate to load individual types.
1168  static void loadData(UT_IStream &is, int64 &v)
1169  { is.bread(&v, 1); }
1170  static void loadData(UT_IStream &is, bool &v)
1171  { int64 iv; is.bread(&iv, 1); v = iv; }
1172  static void loadData(UT_IStream &is, fpreal64 &v)
1173  { is.bread<fpreal64>(&v, 1); }
1174  static void loadData(UT_IStream &is, UT_Vector2D &v)
1175  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
1176  static void loadData(UT_IStream &is, UT_Vector3D &v)
1177  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1178  is.bread<fpreal64>(&v.z(), 1); }
1179  static void loadData(UT_IStream &is, UT_Vector4D &v)
1180  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1181  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
1182  static void loadData(UT_IStream &is, UT_Matrix2D &v)
1183  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
1184  static void loadData(UT_IStream &is, UT_Matrix3D &v)
1185  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
1186  static void loadData(UT_IStream &is, UT_Matrix4D &v)
1187  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
1188  static void loadData(UT_IStream &is, UT_Vector2I &v)
1189  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
1190  static void loadData(UT_IStream &is, UT_Vector3I &v)
1191  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1192  is.bread<int64>(&v.z(), 1); }
1193  static void loadData(UT_IStream &is, UT_Vector4I &v)
1194  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1195  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
1197  { is.bread(v); }
1199  { UT_StringHolder rampdata;
1200  loadData(is, rampdata);
1201  if (rampdata.isstring())
1202  {
1203  v.reset(new UT_Ramp());
1204  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
1205  v->load(istr);
1206  }
1207  else v.reset();
1208  }
1211  loadData(is, data);
1212  if (data.isstring())
1213  {
1214  // Find the data type.
1215  char *colon = UT_StringWrap(data).findChar(':');
1216  if (colon)
1217  {
1218  int typelen = colon - data.buffer();
1220  type.strncpy(data.buffer(), typelen);
1221  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1222 
1223  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1224  }
1225  }
1226  else v.reset();
1227  }
1228 
1229  static void saveData(std::ostream &os, int64 v)
1230  { UTwrite(os, &v); }
1231  static void saveData(std::ostream &os, bool v)
1232  { int64 iv = v; UTwrite(os, &iv); }
1233  static void saveData(std::ostream &os, fpreal64 v)
1234  { UTwrite<fpreal64>(os, &v); }
1235  static void saveData(std::ostream &os, UT_Vector2D v)
1236  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1237  static void saveData(std::ostream &os, UT_Vector3D v)
1238  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1239  UTwrite<fpreal64>(os, &v.z()); }
1240  static void saveData(std::ostream &os, UT_Vector4D v)
1241  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1242  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1243  static void saveData(std::ostream &os, UT_Matrix2D v)
1244  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1245  static void saveData(std::ostream &os, UT_Matrix3D v)
1246  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1247  static void saveData(std::ostream &os, UT_Matrix4D v)
1248  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1249  static void saveData(std::ostream &os, UT_StringHolder s)
1250  { UT_StringWrap(s).saveBinary(os); }
1251  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1252  { UT_StringHolder result;
1253  UT_OStringStream ostr;
1254  if (s) s->save(ostr);
1255  result = ostr.str();
1256  saveData(os, result);
1257  }
1258  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1259  { UT_StringHolder result;
1260  UT_OStringStream ostr;
1261  if (s)
1262  {
1263  ostr << s->getDataTypeToken();
1264  ostr << ":";
1265  s->saveBinary(ostr);
1266  }
1267  result = ostr.str();
1268  saveData(os, result);
1269  }
1270 
1271 
1272  void save(std::ostream &os) const
1273  {
1274  int32 v = version();
1275  UTwrite(os, &v);
1276  saveData(os, myGroup);
1277  saveData(os, myDoXform);
1278  saveData(os, myDoRot);
1279  saveData(os, myXord);
1280  saveData(os, myRord);
1281  saveData(os, myT);
1282  saveData(os, myR);
1283  saveData(os, myS);
1284  saveData(os, myShear);
1285  saveData(os, myP);
1286  saveData(os, myPr);
1287  saveData(os, myLookatpath);
1288  saveData(os, myUpvector);
1289  saveData(os, myXformattribs);
1290  saveData(os, myDoclr);
1291  saveData(os, myDiff);
1292  saveData(os, myDoalpha);
1293  saveData(os, myAlpha);
1294  saveData(os, myDocrease);
1295  saveData(os, myCrease);
1296  saveData(os, myDotexture);
1297  saveData(os, myTexture);
1298  saveData(os, myCloseu);
1299  saveData(os, myClosev);
1300  saveData(os, myClampu);
1301  saveData(os, myClampv);
1302  saveData(os, myVtxsort);
1303  saveData(os, myVtxuoff);
1304  saveData(os, myVtxvoff);
1305  saveData(os, myDoweight);
1306  saveData(os, myMetaweight);
1307  saveData(os, myDoprender);
1308  saveData(os, myPrtype);
1309  saveData(os, myPrsize);
1310  saveData(os, myPrblur);
1311  saveData(os, myDovolvis);
1312  saveData(os, myVolvis);
1313  saveData(os, myVolvisiso);
1314  saveData(os, myVolvisdensity);
1315  saveData(os, myDotaper);
1316  saveData(os, myTaper);
1317  saveData(os, myDovolume);
1318  saveData(os, myVolborder);
1319  saveData(os, myVolborderval);
1320  saveData(os, myDovoltol);
1321  saveData(os, myVoltol);
1322  saveData(os, myDovdbclass);
1323  saveData(os, myVdbclass);
1324  saveData(os, myDovdbcreator);
1325  saveData(os, myVdbcreator);
1326  saveData(os, myDovdbtransform);
1327  saveData(os, myVdbtransform);
1328  saveData(os, myDovdbvectype);
1329  saveData(os, myVdbvectype);
1330  saveData(os, myDovdbhalf);
1331  saveData(os, myVdbhalf);
1332  saveData(os, myTemplategrp);
1333  saveData(os, myPshapeu);
1334  saveData(os, myPshapev);
1335 
1336  }
1337 
1338  bool load(UT_IStream &is)
1339  {
1340  int32 v;
1341  is.bread(&v, 1);
1342  if (version() != v)
1343  {
1344  // Fail incompatible versions
1345  return false;
1346  }
1347  loadData(is, myGroup);
1348  loadData(is, myDoXform);
1349  loadData(is, myDoRot);
1350  loadData(is, myXord);
1351  loadData(is, myRord);
1352  loadData(is, myT);
1353  loadData(is, myR);
1354  loadData(is, myS);
1355  loadData(is, myShear);
1356  loadData(is, myP);
1357  loadData(is, myPr);
1358  loadData(is, myLookatpath);
1359  loadData(is, myUpvector);
1360  loadData(is, myXformattribs);
1361  loadData(is, myDoclr);
1362  loadData(is, myDiff);
1363  loadData(is, myDoalpha);
1364  loadData(is, myAlpha);
1365  loadData(is, myDocrease);
1366  loadData(is, myCrease);
1367  loadData(is, myDotexture);
1368  loadData(is, myTexture);
1369  loadData(is, myCloseu);
1370  loadData(is, myClosev);
1371  loadData(is, myClampu);
1372  loadData(is, myClampv);
1373  loadData(is, myVtxsort);
1374  loadData(is, myVtxuoff);
1375  loadData(is, myVtxvoff);
1376  loadData(is, myDoweight);
1377  loadData(is, myMetaweight);
1378  loadData(is, myDoprender);
1379  loadData(is, myPrtype);
1380  loadData(is, myPrsize);
1381  loadData(is, myPrblur);
1382  loadData(is, myDovolvis);
1383  loadData(is, myVolvis);
1384  loadData(is, myVolvisiso);
1385  loadData(is, myVolvisdensity);
1386  loadData(is, myDotaper);
1387  loadData(is, myTaper);
1388  loadData(is, myDovolume);
1389  loadData(is, myVolborder);
1390  loadData(is, myVolborderval);
1391  loadData(is, myDovoltol);
1392  loadData(is, myVoltol);
1393  loadData(is, myDovdbclass);
1394  loadData(is, myVdbclass);
1395  loadData(is, myDovdbcreator);
1396  loadData(is, myVdbcreator);
1397  loadData(is, myDovdbtransform);
1398  loadData(is, myVdbtransform);
1399  loadData(is, myDovdbvectype);
1400  loadData(is, myVdbvectype);
1401  loadData(is, myDovdbhalf);
1402  loadData(is, myVdbhalf);
1403  loadData(is, myTemplategrp);
1404  loadData(is, myPshapeu);
1405  loadData(is, myPshapev);
1406 
1407  return true;
1408  }
1409 
1410  const UT_StringHolder & getGroup() const { return myGroup; }
1411  void setGroup(const UT_StringHolder & val) { myGroup = val; }
1413  {
1414  SOP_Node *thissop = cookparms.getNode();
1415  if (!thissop) return getGroup();
1416  UT_StringHolder result;
1417  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
1418  return result;
1419  }
1420  bool getDoXform() const { return myDoXform; }
1421  void setDoXform(bool val) { myDoXform = val; }
1422  bool opDoXform(const SOP_NodeVerb::CookParms &cookparms) const
1423  {
1424  SOP_Node *thissop = cookparms.getNode();
1425  if (!thissop) return getDoXform();
1426  bool result;
1427  OP_Utils::evalOpParm(result, thissop, "doxform", cookparms.getCookTime(), 0);
1428  return result;
1429  }
1430  DoRot getDoRot() const { return DoRot(myDoRot); }
1431  void setDoRot(DoRot val) { myDoRot = int64(val); }
1432  DoRot opDoRot(const SOP_NodeVerb::CookParms &cookparms) const
1433  {
1434  SOP_Node *thissop = cookparms.getNode();
1435  if (!thissop) return getDoRot();
1436  int64 result;
1437  OP_Utils::evalOpParm(result, thissop, "dorot", cookparms.getCookTime(), 0);
1438  return DoRot(result);
1439  }
1440  Xord getXord() const { return Xord(myXord); }
1441  void setXord(Xord val) { myXord = int64(val); }
1442  Xord opXord(const SOP_NodeVerb::CookParms &cookparms) const
1443  {
1444  SOP_Node *thissop = cookparms.getNode();
1445  if (!thissop) return getXord();
1446  int64 result;
1447  OP_Utils::evalOpParm(result, thissop, "xOrd", cookparms.getCookTime(), 0);
1448  return Xord(result);
1449  }
1450  Rord getRord() const { return Rord(myRord); }
1451  void setRord(Rord val) { myRord = int64(val); }
1452  Rord opRord(const SOP_NodeVerb::CookParms &cookparms) const
1453  {
1454  SOP_Node *thissop = cookparms.getNode();
1455  if (!thissop) return getRord();
1456  int64 result;
1457  OP_Utils::evalOpParm(result, thissop, "rOrd", cookparms.getCookTime(), 0);
1458  return Rord(result);
1459  }
1460  UT_Vector3D getT() const { return myT; }
1461  void setT(UT_Vector3D val) { myT = val; }
1462  UT_Vector3D opT(const SOP_NodeVerb::CookParms &cookparms) const
1463  {
1464  SOP_Node *thissop = cookparms.getNode();
1465  if (!thissop) return getT();
1466  UT_Vector3D result;
1467  OP_Utils::evalOpParm(result, thissop, "t", cookparms.getCookTime(), 0);
1468  return result;
1469  }
1470  UT_Vector3D getR() const { return myR; }
1471  void setR(UT_Vector3D val) { myR = val; }
1472  UT_Vector3D opR(const SOP_NodeVerb::CookParms &cookparms) const
1473  {
1474  SOP_Node *thissop = cookparms.getNode();
1475  if (!thissop) return getR();
1476  UT_Vector3D result;
1477  OP_Utils::evalOpParm(result, thissop, "r", cookparms.getCookTime(), 0);
1478  return result;
1479  }
1480  UT_Vector3D getS() const { return myS; }
1481  void setS(UT_Vector3D val) { myS = val; }
1482  UT_Vector3D opS(const SOP_NodeVerb::CookParms &cookparms) const
1483  {
1484  SOP_Node *thissop = cookparms.getNode();
1485  if (!thissop) return getS();
1486  UT_Vector3D result;
1487  OP_Utils::evalOpParm(result, thissop, "s", cookparms.getCookTime(), 0);
1488  return result;
1489  }
1490  UT_Vector3D getShear() const { return myShear; }
1491  void setShear(UT_Vector3D val) { myShear = val; }
1493  {
1494  SOP_Node *thissop = cookparms.getNode();
1495  if (!thissop) return getShear();
1496  UT_Vector3D result;
1497  OP_Utils::evalOpParm(result, thissop, "shear", cookparms.getCookTime(), 0);
1498  return result;
1499  }
1500  UT_Vector3D getP() const { return myP; }
1501  void setP(UT_Vector3D val) { myP = val; }
1502  UT_Vector3D opP(const SOP_NodeVerb::CookParms &cookparms) const
1503  {
1504  SOP_Node *thissop = cookparms.getNode();
1505  if (!thissop) return getP();
1506  UT_Vector3D result;
1507  OP_Utils::evalOpParm(result, thissop, "p", cookparms.getCookTime(), 0);
1508  return result;
1509  }
1510  UT_Vector3D getPr() const { return myPr; }
1511  void setPr(UT_Vector3D val) { myPr = val; }
1512  UT_Vector3D opPr(const SOP_NodeVerb::CookParms &cookparms) const
1513  {
1514  SOP_Node *thissop = cookparms.getNode();
1515  if (!thissop) return getPr();
1516  UT_Vector3D result;
1517  OP_Utils::evalOpParm(result, thissop, "pr", cookparms.getCookTime(), 0);
1518  return result;
1519  }
1520  const UT_StringHolder & getLookatpath() const { return myLookatpath; }
1521  void setLookatpath(const UT_StringHolder & val) { myLookatpath = val; }
1523  {
1524  SOP_Node *thissop = cookparms.getNode();
1525  if (!thissop) return getLookatpath();
1526  UT_StringHolder result;
1527  OP_Utils::evalOpParm(result, thissop, "lookatpath", cookparms.getCookTime(), 0);
1528  return result;
1529  }
1530  UT_Vector3D getUpvector() const { return myUpvector; }
1531  void setUpvector(UT_Vector3D val) { myUpvector = val; }
1533  {
1534  SOP_Node *thissop = cookparms.getNode();
1535  if (!thissop) return getUpvector();
1536  UT_Vector3D result;
1537  OP_Utils::evalOpParm(result, thissop, "upvector", cookparms.getCookTime(), 0);
1538  return result;
1539  }
1540  const UT_StringHolder & getXformattribs() const { return myXformattribs; }
1541  void setXformattribs(const UT_StringHolder & val) { myXformattribs = val; }
1543  {
1544  SOP_Node *thissop = cookparms.getNode();
1545  if (!thissop) return getXformattribs();
1546  UT_StringHolder result;
1547  OP_Utils::evalOpParm(result, thissop, "xformattribs", cookparms.getCookTime(), 0);
1548  return result;
1549  }
1550  Doclr getDoclr() const { return Doclr(myDoclr); }
1551  void setDoclr(Doclr val) { myDoclr = int64(val); }
1552  Doclr opDoclr(const SOP_NodeVerb::CookParms &cookparms) const
1553  {
1554  SOP_Node *thissop = cookparms.getNode();
1555  if (!thissop) return getDoclr();
1556  int64 result;
1557  OP_Utils::evalOpParm(result, thissop, "doclr", cookparms.getCookTime(), 0);
1558  return Doclr(result);
1559  }
1560  UT_Vector3D getDiff() const { return myDiff; }
1561  void setDiff(UT_Vector3D val) { myDiff = val; }
1563  {
1564  SOP_Node *thissop = cookparms.getNode();
1565  if (!thissop) return getDiff();
1566  UT_Vector3D result;
1567  OP_Utils::evalOpParm(result, thissop, "diff", cookparms.getCookTime(), 0);
1568  return result;
1569  }
1570  Doalpha getDoalpha() const { return Doalpha(myDoalpha); }
1571  void setDoalpha(Doalpha val) { myDoalpha = int64(val); }
1573  {
1574  SOP_Node *thissop = cookparms.getNode();
1575  if (!thissop) return getDoalpha();
1576  int64 result;
1577  OP_Utils::evalOpParm(result, thissop, "doalpha", cookparms.getCookTime(), 0);
1578  return Doalpha(result);
1579  }
1580  fpreal64 getAlpha() const { return myAlpha; }
1581  void setAlpha(fpreal64 val) { myAlpha = val; }
1582  fpreal64 opAlpha(const SOP_NodeVerb::CookParms &cookparms) const
1583  {
1584  SOP_Node *thissop = cookparms.getNode();
1585  if (!thissop) return getAlpha();
1586  fpreal64 result;
1587  OP_Utils::evalOpParm(result, thissop, "alpha", cookparms.getCookTime(), 0);
1588  return result;
1589  }
1590  Docrease getDocrease() const { return Docrease(myDocrease); }
1591  void setDocrease(Docrease val) { myDocrease = int64(val); }
1593  {
1594  SOP_Node *thissop = cookparms.getNode();
1595  if (!thissop) return getDocrease();
1596  int64 result;
1597  OP_Utils::evalOpParm(result, thissop, "docrease", cookparms.getCookTime(), 0);
1598  return Docrease(result);
1599  }
1600  fpreal64 getCrease() const { return myCrease; }
1601  void setCrease(fpreal64 val) { myCrease = val; }
1603  {
1604  SOP_Node *thissop = cookparms.getNode();
1605  if (!thissop) return getCrease();
1606  fpreal64 result;
1607  OP_Utils::evalOpParm(result, thissop, "crease", cookparms.getCookTime(), 0);
1608  return result;
1609  }
1610  Dotexture getDotexture() const { return Dotexture(myDotexture); }
1611  void setDotexture(Dotexture val) { myDotexture = int64(val); }
1613  {
1614  SOP_Node *thissop = cookparms.getNode();
1615  if (!thissop) return getDotexture();
1616  int64 result;
1617  OP_Utils::evalOpParm(result, thissop, "dotexture", cookparms.getCookTime(), 0);
1618  return Dotexture(result);
1619  }
1620  const UT_StringHolder & getTexture() const { return myTexture; }
1621  void setTexture(const UT_StringHolder & val) { myTexture = val; }
1623  {
1624  SOP_Node *thissop = cookparms.getNode();
1625  if (!thissop) return getTexture();
1626  UT_StringHolder result;
1627  OP_Utils::evalOpParm(result, thissop, "texture", cookparms.getCookTime(), 0);
1628  return result;
1629  }
1630  Closeu getCloseu() const { return Closeu(myCloseu); }
1631  void setCloseu(Closeu val) { myCloseu = int64(val); }
1632  Closeu opCloseu(const SOP_NodeVerb::CookParms &cookparms) const
1633  {
1634  SOP_Node *thissop = cookparms.getNode();
1635  if (!thissop) return getCloseu();
1636  int64 result;
1637  OP_Utils::evalOpParm(result, thissop, "closeu", cookparms.getCookTime(), 0);
1638  return Closeu(result);
1639  }
1640  Closev getClosev() const { return Closev(myClosev); }
1641  void setClosev(Closev val) { myClosev = int64(val); }
1642  Closev opClosev(const SOP_NodeVerb::CookParms &cookparms) const
1643  {
1644  SOP_Node *thissop = cookparms.getNode();
1645  if (!thissop) return getClosev();
1646  int64 result;
1647  OP_Utils::evalOpParm(result, thissop, "closev", cookparms.getCookTime(), 0);
1648  return Closev(result);
1649  }
1650  Clampu getClampu() const { return Clampu(myClampu); }
1651  void setClampu(Clampu val) { myClampu = int64(val); }
1652  Clampu opClampu(const SOP_NodeVerb::CookParms &cookparms) const
1653  {
1654  SOP_Node *thissop = cookparms.getNode();
1655  if (!thissop) return getClampu();
1656  int64 result;
1657  OP_Utils::evalOpParm(result, thissop, "clampu", cookparms.getCookTime(), 0);
1658  return Clampu(result);
1659  }
1660  Clampv getClampv() const { return Clampv(myClampv); }
1661  void setClampv(Clampv val) { myClampv = int64(val); }
1662  Clampv opClampv(const SOP_NodeVerb::CookParms &cookparms) const
1663  {
1664  SOP_Node *thissop = cookparms.getNode();
1665  if (!thissop) return getClampv();
1666  int64 result;
1667  OP_Utils::evalOpParm(result, thissop, "clampv", cookparms.getCookTime(), 0);
1668  return Clampv(result);
1669  }
1670  Vtxsort getVtxsort() const { return Vtxsort(myVtxsort); }
1671  void setVtxsort(Vtxsort val) { myVtxsort = int64(val); }
1673  {
1674  SOP_Node *thissop = cookparms.getNode();
1675  if (!thissop) return getVtxsort();
1676  int64 result;
1677  OP_Utils::evalOpParm(result, thissop, "vtxsort", cookparms.getCookTime(), 0);
1678  return Vtxsort(result);
1679  }
1680  int64 getVtxuoff() const { return myVtxuoff; }
1681  void setVtxuoff(int64 val) { myVtxuoff = val; }
1682  int64 opVtxuoff(const SOP_NodeVerb::CookParms &cookparms) const
1683  {
1684  SOP_Node *thissop = cookparms.getNode();
1685  if (!thissop) return getVtxuoff();
1686  int64 result;
1687  OP_Utils::evalOpParm(result, thissop, "vtxuoff", cookparms.getCookTime(), 0);
1688  return result;
1689  }
1690  int64 getVtxvoff() const { return myVtxvoff; }
1691  void setVtxvoff(int64 val) { myVtxvoff = val; }
1692  int64 opVtxvoff(const SOP_NodeVerb::CookParms &cookparms) const
1693  {
1694  SOP_Node *thissop = cookparms.getNode();
1695  if (!thissop) return getVtxvoff();
1696  int64 result;
1697  OP_Utils::evalOpParm(result, thissop, "vtxvoff", cookparms.getCookTime(), 0);
1698  return result;
1699  }
1700  bool getDoweight() const { return myDoweight; }
1701  void setDoweight(bool val) { myDoweight = val; }
1702  bool opDoweight(const SOP_NodeVerb::CookParms &cookparms) const
1703  {
1704  SOP_Node *thissop = cookparms.getNode();
1705  if (!thissop) return getDoweight();
1706  bool result;
1707  OP_Utils::evalOpParm(result, thissop, "doweight", cookparms.getCookTime(), 0);
1708  return result;
1709  }
1710  fpreal64 getMetaweight() const { return myMetaweight; }
1711  void setMetaweight(fpreal64 val) { myMetaweight = val; }
1713  {
1714  SOP_Node *thissop = cookparms.getNode();
1715  if (!thissop) return getMetaweight();
1716  fpreal64 result;
1717  OP_Utils::evalOpParm(result, thissop, "metaweight", cookparms.getCookTime(), 0);
1718  return result;
1719  }
1720  bool getDoprender() const { return myDoprender; }
1721  void setDoprender(bool val) { myDoprender = val; }
1722  bool opDoprender(const SOP_NodeVerb::CookParms &cookparms) const
1723  {
1724  SOP_Node *thissop = cookparms.getNode();
1725  if (!thissop) return getDoprender();
1726  bool result;
1727  OP_Utils::evalOpParm(result, thissop, "doprender", cookparms.getCookTime(), 0);
1728  return result;
1729  }
1730  Prtype getPrtype() const { return Prtype(myPrtype); }
1731  void setPrtype(Prtype val) { myPrtype = int64(val); }
1732  Prtype opPrtype(const SOP_NodeVerb::CookParms &cookparms) const
1733  {
1734  SOP_Node *thissop = cookparms.getNode();
1735  if (!thissop) return getPrtype();
1736  int64 result;
1737  OP_Utils::evalOpParm(result, thissop, "prtype", cookparms.getCookTime(), 0);
1738  return Prtype(result);
1739  }
1740  fpreal64 getPrsize() const { return myPrsize; }
1741  void setPrsize(fpreal64 val) { myPrsize = val; }
1743  {
1744  SOP_Node *thissop = cookparms.getNode();
1745  if (!thissop) return getPrsize();
1746  fpreal64 result;
1747  OP_Utils::evalOpParm(result, thissop, "prsize", cookparms.getCookTime(), 0);
1748  return result;
1749  }
1750  fpreal64 getPrblur() const { return myPrblur; }
1751  void setPrblur(fpreal64 val) { myPrblur = val; }
1753  {
1754  SOP_Node *thissop = cookparms.getNode();
1755  if (!thissop) return getPrblur();
1756  fpreal64 result;
1757  OP_Utils::evalOpParm(result, thissop, "prblur", cookparms.getCookTime(), 0);
1758  return result;
1759  }
1760  bool getDovolvis() const { return myDovolvis; }
1761  void setDovolvis(bool val) { myDovolvis = val; }
1762  bool opDovolvis(const SOP_NodeVerb::CookParms &cookparms) const
1763  {
1764  SOP_Node *thissop = cookparms.getNode();
1765  if (!thissop) return getDovolvis();
1766  bool result;
1767  OP_Utils::evalOpParm(result, thissop, "dovolvis", cookparms.getCookTime(), 0);
1768  return result;
1769  }
1770  Volvis getVolvis() const { return Volvis(myVolvis); }
1771  void setVolvis(Volvis val) { myVolvis = int64(val); }
1772  Volvis opVolvis(const SOP_NodeVerb::CookParms &cookparms) const
1773  {
1774  SOP_Node *thissop = cookparms.getNode();
1775  if (!thissop) return getVolvis();
1776  int64 result;
1777  OP_Utils::evalOpParm(result, thissop, "volvis", cookparms.getCookTime(), 0);
1778  return Volvis(result);
1779  }
1780  fpreal64 getVolvisiso() const { return myVolvisiso; }
1781  void setVolvisiso(fpreal64 val) { myVolvisiso = val; }
1783  {
1784  SOP_Node *thissop = cookparms.getNode();
1785  if (!thissop) return getVolvisiso();
1786  fpreal64 result;
1787  OP_Utils::evalOpParm(result, thissop, "volvisiso", cookparms.getCookTime(), 0);
1788  return result;
1789  }
1790  fpreal64 getVolvisdensity() const { return myVolvisdensity; }
1791  void setVolvisdensity(fpreal64 val) { myVolvisdensity = val; }
1793  {
1794  SOP_Node *thissop = cookparms.getNode();
1795  if (!thissop) return getVolvisdensity();
1796  fpreal64 result;
1797  OP_Utils::evalOpParm(result, thissop, "volvisdensity", cookparms.getCookTime(), 0);
1798  return result;
1799  }
1800  bool getDotaper() const { return myDotaper; }
1801  void setDotaper(bool val) { myDotaper = val; }
1802  bool opDotaper(const SOP_NodeVerb::CookParms &cookparms) const
1803  {
1804  SOP_Node *thissop = cookparms.getNode();
1805  if (!thissop) return getDotaper();
1806  bool result;
1807  OP_Utils::evalOpParm(result, thissop, "dotaper", cookparms.getCookTime(), 0);
1808  return result;
1809  }
1810  UT_Vector2D getTaper() const { return myTaper; }
1811  void setTaper(UT_Vector2D val) { myTaper = val; }
1813  {
1814  SOP_Node *thissop = cookparms.getNode();
1815  if (!thissop) return getTaper();
1816  UT_Vector2D result;
1817  OP_Utils::evalOpParm(result, thissop, "taper", cookparms.getCookTime(), 0);
1818  return result;
1819  }
1820  bool getDovolume() const { return myDovolume; }
1821  void setDovolume(bool val) { myDovolume = val; }
1822  bool opDovolume(const SOP_NodeVerb::CookParms &cookparms) const
1823  {
1824  SOP_Node *thissop = cookparms.getNode();
1825  if (!thissop) return getDovolume();
1826  bool result;
1827  OP_Utils::evalOpParm(result, thissop, "dovolume", cookparms.getCookTime(), 0);
1828  return result;
1829  }
1830  Volborder getVolborder() const { return Volborder(myVolborder); }
1831  void setVolborder(Volborder val) { myVolborder = int64(val); }
1833  {
1834  SOP_Node *thissop = cookparms.getNode();
1835  if (!thissop) return getVolborder();
1836  int64 result;
1837  OP_Utils::evalOpParm(result, thissop, "volborder", cookparms.getCookTime(), 0);
1838  return Volborder(result);
1839  }
1840  fpreal64 getVolborderval() const { return myVolborderval; }
1841  void setVolborderval(fpreal64 val) { myVolborderval = val; }
1843  {
1844  SOP_Node *thissop = cookparms.getNode();
1845  if (!thissop) return getVolborderval();
1846  fpreal64 result;
1847  OP_Utils::evalOpParm(result, thissop, "volborderval", cookparms.getCookTime(), 0);
1848  return result;
1849  }
1850  bool getDovoltol() const { return myDovoltol; }
1851  void setDovoltol(bool val) { myDovoltol = val; }
1852  bool opDovoltol(const SOP_NodeVerb::CookParms &cookparms) const
1853  {
1854  SOP_Node *thissop = cookparms.getNode();
1855  if (!thissop) return getDovoltol();
1856  bool result;
1857  OP_Utils::evalOpParm(result, thissop, "dovoltol", cookparms.getCookTime(), 0);
1858  return result;
1859  }
1860  fpreal64 getVoltol() const { return myVoltol; }
1861  void setVoltol(fpreal64 val) { myVoltol = val; }
1863  {
1864  SOP_Node *thissop = cookparms.getNode();
1865  if (!thissop) return getVoltol();
1866  fpreal64 result;
1867  OP_Utils::evalOpParm(result, thissop, "voltol", cookparms.getCookTime(), 0);
1868  return result;
1869  }
1870  bool getDovdbclass() const { return myDovdbclass; }
1871  void setDovdbclass(bool val) { myDovdbclass = val; }
1872  bool opDovdbclass(const SOP_NodeVerb::CookParms &cookparms) const
1873  {
1874  SOP_Node *thissop = cookparms.getNode();
1875  if (!thissop) return getDovdbclass();
1876  bool result;
1877  OP_Utils::evalOpParm(result, thissop, "dovdbclass", cookparms.getCookTime(), 0);
1878  return result;
1879  }
1880  int64 getVdbclass() const { return myVdbclass; }
1881  void setVdbclass(int64 val) { myVdbclass = val; }
1882  int64 opVdbclass(const SOP_NodeVerb::CookParms &cookparms) const
1883  {
1884  SOP_Node *thissop = cookparms.getNode();
1885  if (!thissop) return getVdbclass();
1886  int64 result;
1887  OP_Utils::evalOpParm(result, thissop, "vdbclass", cookparms.getCookTime(), 0);
1888  return result;
1889  }
1890  bool getDovdbcreator() const { return myDovdbcreator; }
1891  void setDovdbcreator(bool val) { myDovdbcreator = val; }
1892  bool opDovdbcreator(const SOP_NodeVerb::CookParms &cookparms) const
1893  {
1894  SOP_Node *thissop = cookparms.getNode();
1895  if (!thissop) return getDovdbcreator();
1896  bool result;
1897  OP_Utils::evalOpParm(result, thissop, "dovdbcreator", cookparms.getCookTime(), 0);
1898  return result;
1899  }
1900  const UT_StringHolder & getVdbcreator() const { return myVdbcreator; }
1901  void setVdbcreator(const UT_StringHolder & val) { myVdbcreator = val; }
1903  {
1904  SOP_Node *thissop = cookparms.getNode();
1905  if (!thissop) return getVdbcreator();
1906  UT_StringHolder result;
1907  OP_Utils::evalOpParm(result, thissop, "vdbcreator", cookparms.getCookTime(), 0);
1908  return result;
1909  }
1910  bool getDovdbtransform() const { return myDovdbtransform; }
1911  void setDovdbtransform(bool val) { myDovdbtransform = val; }
1912  bool opDovdbtransform(const SOP_NodeVerb::CookParms &cookparms) const
1913  {
1914  SOP_Node *thissop = cookparms.getNode();
1915  if (!thissop) return getDovdbtransform();
1916  bool result;
1917  OP_Utils::evalOpParm(result, thissop, "dovdbtransform", cookparms.getCookTime(), 0);
1918  return result;
1919  }
1920  bool getVdbtransform() const { return myVdbtransform; }
1921  void setVdbtransform(bool val) { myVdbtransform = val; }
1922  bool opVdbtransform(const SOP_NodeVerb::CookParms &cookparms) const
1923  {
1924  SOP_Node *thissop = cookparms.getNode();
1925  if (!thissop) return getVdbtransform();
1926  bool result;
1927  OP_Utils::evalOpParm(result, thissop, "vdbtransform", cookparms.getCookTime(), 0);
1928  return result;
1929  }
1930  bool getDovdbvectype() const { return myDovdbvectype; }
1931  void setDovdbvectype(bool val) { myDovdbvectype = val; }
1932  bool opDovdbvectype(const SOP_NodeVerb::CookParms &cookparms) const
1933  {
1934  SOP_Node *thissop = cookparms.getNode();
1935  if (!thissop) return getDovdbvectype();
1936  bool result;
1937  OP_Utils::evalOpParm(result, thissop, "dovdbvectype", cookparms.getCookTime(), 0);
1938  return result;
1939  }
1940  int64 getVdbvectype() const { return myVdbvectype; }
1941  void setVdbvectype(int64 val) { myVdbvectype = val; }
1943  {
1944  SOP_Node *thissop = cookparms.getNode();
1945  if (!thissop) return getVdbvectype();
1946  int64 result;
1947  OP_Utils::evalOpParm(result, thissop, "vdbvectype", cookparms.getCookTime(), 0);
1948  return result;
1949  }
1950  bool getDovdbhalf() const { return myDovdbhalf; }
1951  void setDovdbhalf(bool val) { myDovdbhalf = val; }
1952  bool opDovdbhalf(const SOP_NodeVerb::CookParms &cookparms) const
1953  {
1954  SOP_Node *thissop = cookparms.getNode();
1955  if (!thissop) return getDovdbhalf();
1956  bool result;
1957  OP_Utils::evalOpParm(result, thissop, "dovdbhalf", cookparms.getCookTime(), 0);
1958  return result;
1959  }
1960  bool getVdbhalf() const { return myVdbhalf; }
1961  void setVdbhalf(bool val) { myVdbhalf = val; }
1962  bool opVdbhalf(const SOP_NodeVerb::CookParms &cookparms) const
1963  {
1964  SOP_Node *thissop = cookparms.getNode();
1965  if (!thissop) return getVdbhalf();
1966  bool result;
1967  OP_Utils::evalOpParm(result, thissop, "vdbhalf", cookparms.getCookTime(), 0);
1968  return result;
1969  }
1970  const UT_StringHolder & getTemplategrp() const { return myTemplategrp; }
1971  void setTemplategrp(const UT_StringHolder & val) { myTemplategrp = val; }
1973  {
1974  SOP_Node *thissop = cookparms.getNode();
1975  if (!thissop) return getTemplategrp();
1976  UT_StringHolder result;
1977  OP_Utils::evalOpParm(result, thissop, "templateGrp", cookparms.getCookTime(), 0);
1978  return result;
1979  }
1980  bool getPshapeu() const { return myPshapeu; }
1981  void setPshapeu(bool val) { myPshapeu = val; }
1982  bool opPshapeu(const SOP_NodeVerb::CookParms &cookparms) const
1983  {
1984  SOP_Node *thissop = cookparms.getNode();
1985  if (!thissop) return getPshapeu();
1986  bool result;
1987  OP_Utils::evalOpParm(result, thissop, "pshapeu", cookparms.getCookTime(), 0);
1988  return result;
1989  }
1990  bool getPshapev() const { return myPshapev; }
1991  void setPshapev(bool val) { myPshapev = val; }
1992  bool opPshapev(const SOP_NodeVerb::CookParms &cookparms) const
1993  {
1994  SOP_Node *thissop = cookparms.getNode();
1995  if (!thissop) return getPshapev();
1996  bool result;
1997  OP_Utils::evalOpParm(result, thissop, "pshapev", cookparms.getCookTime(), 0);
1998  return result;
1999  }
2000 
2001 private:
2002  UT_StringHolder myGroup;
2003  bool myDoXform;
2004  int64 myDoRot;
2005  int64 myXord;
2006  int64 myRord;
2007  UT_Vector3D myT;
2008  UT_Vector3D myR;
2009  UT_Vector3D myS;
2010  UT_Vector3D myShear;
2011  UT_Vector3D myP;
2012  UT_Vector3D myPr;
2013  UT_StringHolder myLookatpath;
2014  UT_Vector3D myUpvector;
2015  UT_StringHolder myXformattribs;
2016  int64 myDoclr;
2017  UT_Vector3D myDiff;
2018  int64 myDoalpha;
2019  fpreal64 myAlpha;
2020  int64 myDocrease;
2021  fpreal64 myCrease;
2022  int64 myDotexture;
2023  UT_StringHolder myTexture;
2024  int64 myCloseu;
2025  int64 myClosev;
2026  int64 myClampu;
2027  int64 myClampv;
2028  int64 myVtxsort;
2029  int64 myVtxuoff;
2030  int64 myVtxvoff;
2031  bool myDoweight;
2032  fpreal64 myMetaweight;
2033  bool myDoprender;
2034  int64 myPrtype;
2035  fpreal64 myPrsize;
2036  fpreal64 myPrblur;
2037  bool myDovolvis;
2038  int64 myVolvis;
2039  fpreal64 myVolvisiso;
2040  fpreal64 myVolvisdensity;
2041  bool myDotaper;
2042  UT_Vector2D myTaper;
2043  bool myDovolume;
2044  int64 myVolborder;
2045  fpreal64 myVolborderval;
2046  bool myDovoltol;
2047  fpreal64 myVoltol;
2048  bool myDovdbclass;
2049  int64 myVdbclass;
2050  bool myDovdbcreator;
2051  UT_StringHolder myVdbcreator;
2052  bool myDovdbtransform;
2053  bool myVdbtransform;
2054  bool myDovdbvectype;
2055  int64 myVdbvectype;
2056  bool myDovdbhalf;
2057  bool myVdbhalf;
2058  UT_StringHolder myTemplategrp;
2059  bool myPshapeu;
2060  bool myPshapev;
2061 
2062 };
void setVolvisdensity(fpreal64 val)
Volborder opVolborder(const SOP_NodeVerb::CookParms &cookparms) const
Docrease getDocrease() const
UT_Vector3D getT() const
static void saveData(std::ostream &os, UT_Matrix2D v)
fpreal64 getAlpha() const
bool opDovdbclass(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getVolborderval() const
void setDovolume(bool val)
UT_Vector3D opDiff(const SOP_NodeVerb::CookParms &cookparms) const
void setDovdbcreator(bool val)
static void loadData(UT_IStream &is, UT_Vector3I &v)
void setParmValue(exint idx, const UT_Vector3D &value)
bool opVdbhalf(const SOP_NodeVerb::CookParms &cookparms) const
Doclr opDoclr(const SOP_NodeVerb::CookParms &cookparms) const
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:494
T & z(void)
Definition: UT_Vector4.h:379
virtual ParmType getParmType(exint fieldnum) const
static void loadData(UT_IStream &is, UT_StringHolder &v)
void setVtxvoff(int64 val)
fpreal64 getPrsize() const
void setParmValue(exint idx, const UT_StringHolder &value)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
static void saveData(std::ostream &os, int64 v)
void setP(UT_Vector3D val)
Vtxsort getVtxsort() const
exint bread(int32 *buffer, exint asize=1)
void setPrsize(fpreal64 val)
GT_API const UT_StringHolder time
fpreal64 getVoltol() const
UT_Vector3D getDiff() const
fpreal getTime() const
Definition: OP_Context.h:60
UT_Vector3D getP() const
const GLdouble * v
Definition: glcorearb.h:836
UT_Vector2T< fpreal64 > UT_Vector2D
void setDoweight(bool val)
fpreal64 getVolvisiso() const
UT_StringHolder opVdbcreator(const SOP_NodeVerb::CookParms &cookparms) const
int64 opVdbclass(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void setXformattribs(const UT_StringHolder &val)
Volvis getVolvis() const
fpreal64 getVolvisdensity() const
Closeu getCloseu() const
int64 getVdbvectype() const
Closeu opCloseu(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, bool v)
SYS_FORCE_INLINE const char * buffer() const
T & x(void)
Definition: UT_Vector2.h:285
void setDovoltol(bool val)
fpreal64 opCrease(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Matrix4D &value) const
bool operator!=(const SOP_PrimitiveParms &src) const
UT_StringHolder opXformattribs(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
void getParmValue(exint idx, UT_Vector3D &value) const
An output stream object that owns its own string buffer storage.
virtual exint getNumParms() const
UT_Vector2D opTaper(const SOP_NodeVerb::CookParms &cookparms) const
void setClampu(Clampu val)
void setParmValue(exint idx, const UT_Matrix2D &value)
void getParmValue(exint idx, UT_StringHolder &value) const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
static void loadData(UT_IStream &is, UT_Vector4D &v)
static void loadData(UT_IStream &is, bool &v)
void setVdbvectype(int64 val)
void setVtxuoff(int64 val)
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:498
int64 opVtxvoff(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void save(std::ostream &os) const
void doSetParmValue(exint idx, const T &value)
bool operator==(const SOP_PrimitiveParms &src) const
Closev opClosev(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opP(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getS() const
fpreal64 opVoltol(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opLookatpath(const SOP_NodeVerb::CookParms &cookparms) const
bool opDovdbtransform(const SOP_NodeVerb::CookParms &cookparms) const
void setPr(UT_Vector3D val)
void setDovdbvectype(bool val)
bool opDovoltol(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getShear() const
Prtype opPrtype(const SOP_NodeVerb::CookParms &cookparms) const
bool opDoweight(const SOP_NodeVerb::CookParms &cookparms) const
void setVdbcreator(const UT_StringHolder &val)
static void saveData(std::ostream &os, PRM_DataItemHandle s)
bool opPshapeu(const SOP_NodeVerb::CookParms &cookparms) const
void setS(UT_Vector3D val)
const UT_StringHolder & getTexture() const
bool getDovdbcreator() const
void setGroup(const UT_StringHolder &val)
void setCrease(fpreal64 val)
void setDoRot(DoRot val)
void setTaper(UT_Vector2D val)
static void loadData(UT_IStream &is, UT_Vector2I &v)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:502
void setParmValue(exint idx, const UT_Matrix4D &value)
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
void setAlpha(fpreal64 val)
bool getDovdbtransform() const
long long int64
Definition: SYS_Types.h:107
Clampu getClampu() const
void setDovdbclass(bool val)
static void saveData(std::ostream &os, UT_Matrix3D v)
bool opDoprender(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, fpreal64 v)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void setT(UT_Vector3D val)
void setVolborderval(fpreal64 val)
void setMetaweight(fpreal64 val)
Prtype getPrtype() const
void setDoalpha(Doalpha val)
UT_Vector3D opUpvector(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector2D &value) const
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
static void saveData(std::ostream &os, UT_StringHolder s)
static void loadData(UT_IStream &is, UT_Vector3D &v)
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
Volvis opVolvis(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opT(const SOP_NodeVerb::CookParms &cookparms) const
int64 exint
Definition: SYS_Types.h:116
void setParmValue(exint idx, const PRM_DataItemHandle &value)
void getParmValue(exint idx, exint &value) const
void getParmValue(exint idx, UT_Matrix2D &value) const
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:192
static void loadData(UT_IStream &is, fpreal64 &v)
void setLookatpath(const UT_StringHolder &val)
const UT_StringHolder & getXformattribs() const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
Xord opXord(const SOP_NodeVerb::CookParms &cookparms) const
OP_Node * getInput(unsigned idx, bool mark_used=false) const
Returns the node connected to a particular input (may be null).
Docrease opDocrease(const SOP_NodeVerb::CookParms &cookparms) const
void setDotexture(Dotexture val)
static void loadData(UT_IStream &is, UT_Vector2D &v)
void getParmValue(exint idx, UT_Vector4D &value) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
UT_Vector3D getPr() const
bool getDovdbvectype() const
static void saveData(std::ostream &os, UT_Vector3D v)
UT_StringHolder opTexture(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3T< fpreal64 > UT_Vector3D
bool opDovdbcreator(const SOP_NodeVerb::CookParms &cookparms) const
bool getVdbtransform() const
GLboolean * data
Definition: glcorearb.h:130
Closev getClosev() const
Rord opRord(const SOP_NodeVerb::CookParms &cookparms) const
int int32
Definition: SYS_Types.h:35
T & y(void)
Definition: UT_Vector4.h:377
void setCloseu(Closeu val)
UT_Vector3D opR(const SOP_NodeVerb::CookParms &cookparms) const
void setDovolvis(bool val)
fpreal64 opPrsize(const SOP_NodeVerb::CookParms &cookparms) const
void setVolvisiso(fpreal64 val)
static void saveData(std::ostream &os, UT_Matrix4D v)
static void saveData(std::ostream &os, UT_Vector4D v)
void setVolvis(Volvis val)
UT_Vector2D getTaper() const
int64 opVdbvectype(const SOP_NodeVerb::CookParms &cookparms) const
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
bool opDotaper(const SOP_NodeVerb::CookParms &cookparms) const
void setDiff(UT_Vector3D val)
bool opPshapev(const SOP_NodeVerb::CookParms &cookparms) const
void setDocrease(Docrease val)
void setParmValue(exint idx, const UT_Matrix3D &value)
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
bool opVdbtransform(const SOP_NodeVerb::CookParms &cookparms) const
void setR(UT_Vector3D val)
fpreal64 getPrblur() 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_Vector2D &value)
void setDovdbtransform(bool val)
virtual const char * getParmName(exint fieldnum) const
void setShear(UT_Vector3D val)
void getParmValue(exint idx, fpreal &value) const
void setVdbtransform(bool val)
fpreal64 opMetaweight(const SOP_NodeVerb::CookParms &cookparms) const
int64 opVtxuoff(const SOP_NodeVerb::CookParms &cookparms) const
void setDovdbhalf(bool val)
UT_Vector3D opS(const SOP_NodeVerb::CookParms &cookparms) const
void setUpvector(UT_Vector3D val)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
Doalpha opDoalpha(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getMetaweight() const
fpreal64 opPrblur(const SOP_NodeVerb::CookParms &cookparms) const
Clampv opClampv(const SOP_NodeVerb::CookParms &cookparms) const
GLuint GLfloat * val
Definition: glcorearb.h:1607
bool load(UT_IStream &is)
#define SOP_API
Definition: SOP_API.h:10
void setVtxsort(Vtxsort val)
UT_Vector3D getR() const
UT_StringHolder opTemplategrp(const SOP_NodeVerb::CookParms &cookparms) const
bool opDovolume(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opVolvisiso(const SOP_NodeVerb::CookParms &cookparms) const
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:501
void setParmValue(exint idx, const UT_Vector4D &value)
T & x(void)
Definition: UT_Vector4.h:375
virtual void loadFromOpSubclass(const LoadParms &loadparms)
UT_Vector3D getUpvector() const
void doGetParmValue(exint idx, T &value) const
T & y(void)
Definition: UT_Vector2.h:287
Clampv getClampv() const
static void saveData(std::ostream &os, UT_Vector2D v)
const UT_StringHolder & getTemplategrp() const
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
void getParmValue(exint idx, UT_Matrix3D &value) const
bool opDovolvis(const SOP_NodeVerb::CookParms &cookparms) const
void setVolborder(Volborder val)
GLboolean r
Definition: glcorearb.h:1221
UT_Vector3D opShear(const SOP_NodeVerb::CookParms &cookparms) const
void setTexture(const UT_StringHolder &val)
bool opDovdbvectype(const SOP_NodeVerb::CookParms &cookparms) const
Dotexture opDotexture(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opPr(const SOP_NodeVerb::CookParms &cookparms) const
bool opDovdbhalf(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getLookatpath() const
T & w(void)
Definition: UT_Vector4.h:381
Dotexture getDotexture() const
void setClosev(Closev val)
fpreal64 opVolvisdensity(const SOP_NodeVerb::CookParms &cookparms) const
Doalpha getDoalpha() const
void setParmValue(exint idx, const exint &value)
const UT_StringHolder & getGroup() const
Volborder getVolborder() const
virtual void copyFrom(const SOP_NodeParms *src)
Vtxsort opVtxsort(const SOP_NodeVerb::CookParms &cookparms) const
void setDoprender(bool val)
void setPrblur(fpreal64 val)
void setPrtype(Prtype val)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
static void loadData(UT_IStream &is, int64 &v)
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:88
fpreal64 getCrease() const
void setClampv(Clampv val)
void setParmValue(exint idx, const fpreal &value)
int64 getVdbclass() const
fpreal64 opAlpha(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
void setVoltol(fpreal64 val)
Clampu opClampu(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
bool opDoXform(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, PRM_DataItemHandle &value) const
void setTemplategrp(const UT_StringHolder &val)
const UT_StringHolder & getVdbcreator() const
fpreal64 opVolborderval(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
void setDoclr(Doclr val)
DoRot opDoRot(const SOP_NodeVerb::CookParms &cookparms) const
GLenum src
Definition: glcorearb.h:1792
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
void setVdbclass(int64 val)