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