HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_GroupCreate.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_GroupCreateEnums
22 {
23  enum class Grouptype
24  {
25  PRIMITIVE = 0,
26  POINT,
27  EDGE
28  };
29  enum class Mergeop
30  {
31  REPLACE = 0,
32  UNION,
33  INTERSECT,
34  SUBTRACT
35  };
36  enum class Boundtype
37  {
38  USEBBOX = 0,
39  USEBSPHERE,
40  USEBOBJECT,
42  };
43 }
44 
45 
47 {
48 public:
49  static int version() { return 1; }
50 
52  {
53  myGroupName = "group1"_sh;
54  myGrouptype = 0;
55  myMergeop = 0;
56  myGroupBase = true;
57  myBasegroup = ""_sh;
58  myOrdered = false;
59  myGeotype = 0;
60  myGroupBounding = false;
61  myBoundtype = 0;
62  mySize = UT_Vector3D(1,1,1);
63  myT = UT_Vector3D(0,0,0);
64  myIncludenotwhollycontained = false;
65  myIso = 0;
66  myInvertvolume = false;
67  myGroupNormal = false;
68  myCamerapath = ""_sh;
69  myNonplanar = false;
70  myNonplanartol = 0.001;
71  myDir = UT_Vector3D(0,0,1);
72  myAngle = 180;
73  myGroupEdges = false;
74  myDominedgeangle = false;
75  myMinedgeangle = 20;
76  myDomaxedgeangle = false;
77  myMaxedgeangle = 20;
78  myEdgeAngleBetweenEdges = false;
79  myDominedgelen = false;
80  myMinedgelen = 0;
81  myDomaxedgelen = false;
82  myMaxedgelen = 0;
83  myDodepth = false;
84  myEdgestep = 0;
85  myEdgeptgrp = "0"_sh;
86  myUnshared = false;
87  myBoundaryGroups = false;
88 
89  }
90 
91  explicit SOP_GroupCreateParms(const SOP_GroupCreateParms &) = default;
92 
93  virtual ~SOP_GroupCreateParms() {}
94 
95  bool operator==(const SOP_GroupCreateParms &src) const
96  {
97  if (myGroupName != src.myGroupName) return false;
98  if (myGrouptype != src.myGrouptype) return false;
99  if (myMergeop != src.myMergeop) return false;
100  if (myGroupBase != src.myGroupBase) return false;
101  if (myBasegroup != src.myBasegroup) return false;
102  if (myOrdered != src.myOrdered) return false;
103  if (myGeotype != src.myGeotype) return false;
104  if (myGroupBounding != src.myGroupBounding) return false;
105  if (myBoundtype != src.myBoundtype) return false;
106  if (mySize != src.mySize) return false;
107  if (myT != src.myT) return false;
108  if (myIncludenotwhollycontained != src.myIncludenotwhollycontained) return false;
109  if (myIso != src.myIso) return false;
110  if (myInvertvolume != src.myInvertvolume) return false;
111  if (myGroupNormal != src.myGroupNormal) return false;
112  if (myCamerapath != src.myCamerapath) return false;
113  if (myNonplanar != src.myNonplanar) return false;
114  if (myNonplanartol != src.myNonplanartol) return false;
115  if (myDir != src.myDir) return false;
116  if (myAngle != src.myAngle) return false;
117  if (myGroupEdges != src.myGroupEdges) return false;
118  if (myDominedgeangle != src.myDominedgeangle) return false;
119  if (myMinedgeangle != src.myMinedgeangle) return false;
120  if (myDomaxedgeangle != src.myDomaxedgeangle) return false;
121  if (myMaxedgeangle != src.myMaxedgeangle) return false;
122  if (myEdgeAngleBetweenEdges != src.myEdgeAngleBetweenEdges) return false;
123  if (myDominedgelen != src.myDominedgelen) return false;
124  if (myMinedgelen != src.myMinedgelen) return false;
125  if (myDomaxedgelen != src.myDomaxedgelen) return false;
126  if (myMaxedgelen != src.myMaxedgelen) return false;
127  if (myDodepth != src.myDodepth) return false;
128  if (myEdgestep != src.myEdgestep) return false;
129  if (myEdgeptgrp != src.myEdgeptgrp) return false;
130  if (myUnshared != src.myUnshared) return false;
131  if (myBoundaryGroups != src.myBoundaryGroups) return false;
132 
133  return true;
134  }
138 
139 
140 
141  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
142  {
143  if (true)
144  OP_Utils::evalOpParm(myGroupName, node, "groupname", time, 0);
145  else myGroupName = "group1"_sh;
146  if (true)
147  OP_Utils::evalOpParm(myGrouptype, node, "grouptype", time, 0);
148  else myGrouptype = 0;
149  if (true)
150  OP_Utils::evalOpParm(myMergeop, node, "mergeop", time, 0);
151  else myMergeop = 0;
152  if (true)
153  OP_Utils::evalOpParm(myGroupBase, node, "groupbase", time, 0);
154  else myGroupBase = true;
155  if (true && ( (!(((getGroupBase()==0)))) ) )
156  OP_Utils::evalOpParm(myBasegroup, node, "basegroup", time, 0);
157  else myBasegroup = ""_sh;
158  if (true && ( (!(((getGroupBase()==0)))) ) )
159  OP_Utils::evalOpParm(myOrdered, node, "ordered", time, 0);
160  else myOrdered = false;
161  if (true && ( (!(((getGroupBase()==0)))) ) )
162  OP_Utils::evalOpParm(myGeotype, node, "geotype", time, 0);
163  else myGeotype = 0;
164  if (true)
165  OP_Utils::evalOpParm(myGroupBounding, node, "groupbounding", time, 0);
166  else myGroupBounding = false;
167  if (true && ( (!(((getGroupBounding()==0)))) ) )
168  OP_Utils::evalOpParm(myBoundtype, node, "boundtype", time, 0);
169  else myBoundtype = 0;
170  if (true && ( (!(((getGroupBounding()==0))||((int64(getBoundtype())!=0)&&(int64(getBoundtype())!=1)))) ) )
171  OP_Utils::evalOpParm(mySize, node, "size", time, 0);
172  else mySize = UT_Vector3D(1,1,1);
173  if (true && ( (!(((getGroupBounding()==0))||((int64(getBoundtype())!=0)&&(int64(getBoundtype())!=1)))) ) )
174  OP_Utils::evalOpParm(myT, node, "t", time, 0);
175  else myT = UT_Vector3D(0,0,0);
176  if (true && ( (!(((getGroupBounding()==0))||((int64(getBoundtype())!=0)&&(int64(getBoundtype())!=1)))) ) )
177  OP_Utils::evalOpParm(myIncludenotwhollycontained, node, "includenotwhollycontained", time, 0);
178  else myIncludenotwhollycontained = false;
179  if (true && ( (!(((getGroupBounding()==0))||((int64(getBoundtype())!=3)))) ) )
180  OP_Utils::evalOpParm(myIso, node, "iso", time, 0);
181  else myIso = 0;
182  if (true && ( (!(((getGroupBounding()==0))||((int64(getBoundtype())!=3)))) ) )
183  OP_Utils::evalOpParm(myInvertvolume, node, "invertvolume", time, 0);
184  else myInvertvolume = false;
185  if (true)
186  OP_Utils::evalOpParm(myGroupNormal, node, "groupnormal", time, 0);
187  else myGroupNormal = false;
188  if (true && ( (!(((getGroupNormal()==0)))) ) )
189  OP_Utils::evalOpParm(myCamerapath, node, "camerapath", time, 0);
190  else myCamerapath = ""_sh;
191  if (true && ( (!(((int64(getGrouptype())!=0))||((getGroupNormal()==0)))) ) )
192  OP_Utils::evalOpParm(myNonplanar, node, "nonplanar", time, 0);
193  else myNonplanar = false;
194  if (true && ( (!(((int64(getGrouptype())!=0))||((getNonplanar()==0))||((getGroupNormal()==0)))) ) )
195  OP_Utils::evalOpParm(myNonplanartol, node, "nonplanartol", time, 0);
196  else myNonplanartol = 0.001;
197  if (true && ( (!(((int64(getGrouptype())==0)&&(getNonplanar()==1))||((getCamerapath()!=""))||((getGroupNormal()==0)))) ) )
198  OP_Utils::evalOpParm(myDir, node, "dir", time, 0);
199  else myDir = UT_Vector3D(0,0,1);
200  if (true && ( (!(((int64(getGrouptype())==0)&&(getNonplanar()==1))||((getCamerapath()!=""))||((getGroupNormal()==0)))) ) )
201  OP_Utils::evalOpParm(myAngle, node, "angle", time, 0);
202  else myAngle = 180;
203  if (true)
204  OP_Utils::evalOpParm(myGroupEdges, node, "groupedges", time, 0);
205  else myGroupEdges = false;
206  if (true && ( (!(((int64(getGrouptype())==1))||((getGroupEdges()==0)))) ) )
207  OP_Utils::evalOpParm(myDominedgeangle, node, "dominedgeangle", time, 0);
208  else myDominedgeangle = false;
209  if (true && ( (!(((int64(getGrouptype())==1))||((getDominedgeangle()==0))||((getGroupEdges()==0)))) ) )
210  OP_Utils::evalOpParm(myMinedgeangle, node, "minedgeangle", time, 0);
211  else myMinedgeangle = 20;
212  if (true && ( (!(((int64(getGrouptype())==1))||((getGroupEdges()==0)))) ) )
213  OP_Utils::evalOpParm(myDomaxedgeangle, node, "domaxedgeangle", time, 0);
214  else myDomaxedgeangle = false;
215  if (true && ( (!(((int64(getGrouptype())==1))||((getDomaxedgeangle()==0))||((getGroupEdges()==0)))) ) )
216  OP_Utils::evalOpParm(myMaxedgeangle, node, "maxedgeangle", time, 0);
217  else myMaxedgeangle = 20;
218  if (true && ( (!(((int64(getGrouptype())!=2))||((getGroupEdges()==0)))) ) )
219  OP_Utils::evalOpParm(myEdgeAngleBetweenEdges, node, "edgeanglebetweenedges", time, 0);
220  else myEdgeAngleBetweenEdges = false;
221  if (true && ( (!(((int64(getGrouptype())!=2))||((getGroupEdges()==0)))) ) )
222  OP_Utils::evalOpParm(myDominedgelen, node, "dominedgelen", time, 0);
223  else myDominedgelen = false;
224  if (true && ( (!(((int64(getGrouptype())!=2))||((getDominedgelen()==0))||((getGroupEdges()==0)))) ) )
225  OP_Utils::evalOpParm(myMinedgelen, node, "minedgelen", time, 0);
226  else myMinedgelen = 0;
227  if (true && ( (!(((int64(getGrouptype())!=2))||((getGroupEdges()==0)))) ) )
228  OP_Utils::evalOpParm(myDomaxedgelen, node, "domaxedgelen", time, 0);
229  else myDomaxedgelen = false;
230  if (true && ( (!(((int64(getGrouptype())!=2))||((getDomaxedgelen()==0))||((getGroupEdges()==0)))) ) )
231  OP_Utils::evalOpParm(myMaxedgelen, node, "maxedgelen", time, 0);
232  else myMaxedgelen = 0;
233  if (true && ( (!(((int64(getGrouptype())!=1))||((getGroupEdges()==0)))) ) )
234  OP_Utils::evalOpParm(myDodepth, node, "dodepth", time, 0);
235  else myDodepth = false;
236  if (true && ( (!(((int64(getGrouptype())!=1))||((getDodepth()==0))||((getGroupEdges()==0)))) ) )
237  OP_Utils::evalOpParm(myEdgestep, node, "edgestep", time, 0);
238  else myEdgestep = 0;
239  if (true && ( (!(((int64(getGrouptype())!=1))||((getDodepth()==0))||((getGroupEdges()==0)))) ) )
240  OP_Utils::evalOpParm(myEdgeptgrp, node, "edgeptgrp", time, 0);
241  else myEdgeptgrp = "0"_sh;
242  if (true && ( (!(((getGroupEdges()==0)))) ) )
243  OP_Utils::evalOpParm(myUnshared, node, "unshared", time, 0);
244  else myUnshared = false;
245  if (true && ( (!(((int64(getGrouptype())!=1))||((getUnshared()==0))||((getGroupEdges()==0)))) ) )
246  OP_Utils::evalOpParm(myBoundaryGroups, node, "boundarygroups", time, 0);
247  else myBoundaryGroups = false;
248 
249  }
250 
251 
252  virtual void loadFromOpSubclass(const LoadParms &loadparms)
253  {
254  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
255  }
256 
257 
258  virtual void copyFrom(const SOP_NodeParms *src)
259  {
260  *this = *((const SOP_GroupCreateParms *)src);
261  }
262 
263  template <typename T>
264  void
265  doGetParmValue(exint idx, T &value) const
266  {
267  switch (idx)
268  {
269  case 0:
270  coerceValue(value, myGroupName);
271  break;
272  case 1:
273  coerceValue(value, myGrouptype);
274  break;
275  case 2:
276  coerceValue(value, myMergeop);
277  break;
278  case 3:
279  coerceValue(value, myGroupBase);
280  break;
281  case 4:
282  coerceValue(value, myBasegroup);
283  break;
284  case 5:
285  coerceValue(value, myOrdered);
286  break;
287  case 6:
288  coerceValue(value, myGeotype);
289  break;
290  case 7:
291  coerceValue(value, myGroupBounding);
292  break;
293  case 8:
294  coerceValue(value, myBoundtype);
295  break;
296  case 9:
297  coerceValue(value, mySize);
298  break;
299  case 10:
300  coerceValue(value, myT);
301  break;
302  case 11:
303  coerceValue(value, myIncludenotwhollycontained);
304  break;
305  case 12:
306  coerceValue(value, myIso);
307  break;
308  case 13:
309  coerceValue(value, myInvertvolume);
310  break;
311  case 14:
312  coerceValue(value, myGroupNormal);
313  break;
314  case 15:
315  coerceValue(value, myCamerapath);
316  break;
317  case 16:
318  coerceValue(value, myNonplanar);
319  break;
320  case 17:
321  coerceValue(value, myNonplanartol);
322  break;
323  case 18:
324  coerceValue(value, myDir);
325  break;
326  case 19:
327  coerceValue(value, myAngle);
328  break;
329  case 20:
330  coerceValue(value, myGroupEdges);
331  break;
332  case 21:
333  coerceValue(value, myDominedgeangle);
334  break;
335  case 22:
336  coerceValue(value, myMinedgeangle);
337  break;
338  case 23:
339  coerceValue(value, myDomaxedgeangle);
340  break;
341  case 24:
342  coerceValue(value, myMaxedgeangle);
343  break;
344  case 25:
345  coerceValue(value, myEdgeAngleBetweenEdges);
346  break;
347  case 26:
348  coerceValue(value, myDominedgelen);
349  break;
350  case 27:
351  coerceValue(value, myMinedgelen);
352  break;
353  case 28:
354  coerceValue(value, myDomaxedgelen);
355  break;
356  case 29:
357  coerceValue(value, myMaxedgelen);
358  break;
359  case 30:
360  coerceValue(value, myDodepth);
361  break;
362  case 31:
363  coerceValue(value, myEdgestep);
364  break;
365  case 32:
366  coerceValue(value, myEdgeptgrp);
367  break;
368  case 33:
369  coerceValue(value, myUnshared);
370  break;
371  case 34:
372  coerceValue(value, myBoundaryGroups);
373  break;
374 
375  }
376  }
377 
378  void getParmValue(exint idx, exint &value) const
379  { doGetParmValue(idx, value); }
380  void getParmValue(exint idx, fpreal &value) const
381  { doGetParmValue(idx, value); }
383  { doGetParmValue(idx, value); }
385  { doGetParmValue(idx, value); }
387  { doGetParmValue(idx, value); }
389  { doGetParmValue(idx, value); }
391  { doGetParmValue(idx, value); }
393  { doGetParmValue(idx, value); }
395  { doGetParmValue(idx, value); }
397  { doGetParmValue(idx, value); }
399  { doGetParmValue(idx, value); }
400 
401  template <typename T>
402  void
403  doSetParmValue(exint idx, const T &value)
404  {
405  switch (idx)
406  {
407  case 0:
408  coerceValue(myGroupName, value);
409  break;
410  case 1:
411  coerceValue(myGrouptype, value);
412  break;
413  case 2:
414  coerceValue(myMergeop, value);
415  break;
416  case 3:
417  coerceValue(myGroupBase, value);
418  break;
419  case 4:
420  coerceValue(myBasegroup, value);
421  break;
422  case 5:
423  coerceValue(myOrdered, value);
424  break;
425  case 6:
426  coerceValue(myGeotype, value);
427  break;
428  case 7:
429  coerceValue(myGroupBounding, value);
430  break;
431  case 8:
432  coerceValue(myBoundtype, value);
433  break;
434  case 9:
435  coerceValue(mySize, value);
436  break;
437  case 10:
438  coerceValue(myT, value);
439  break;
440  case 11:
441  coerceValue(myIncludenotwhollycontained, value);
442  break;
443  case 12:
444  coerceValue(myIso, value);
445  break;
446  case 13:
447  coerceValue(myInvertvolume, value);
448  break;
449  case 14:
450  coerceValue(myGroupNormal, value);
451  break;
452  case 15:
453  coerceValue(myCamerapath, value);
454  break;
455  case 16:
456  coerceValue(myNonplanar, value);
457  break;
458  case 17:
459  coerceValue(myNonplanartol, value);
460  break;
461  case 18:
462  coerceValue(myDir, value);
463  break;
464  case 19:
465  coerceValue(myAngle, value);
466  break;
467  case 20:
468  coerceValue(myGroupEdges, value);
469  break;
470  case 21:
471  coerceValue(myDominedgeangle, value);
472  break;
473  case 22:
474  coerceValue(myMinedgeangle, value);
475  break;
476  case 23:
477  coerceValue(myDomaxedgeangle, value);
478  break;
479  case 24:
480  coerceValue(myMaxedgeangle, value);
481  break;
482  case 25:
483  coerceValue(myEdgeAngleBetweenEdges, value);
484  break;
485  case 26:
486  coerceValue(myDominedgelen, value);
487  break;
488  case 27:
489  coerceValue(myMinedgelen, value);
490  break;
491  case 28:
492  coerceValue(myDomaxedgelen, value);
493  break;
494  case 29:
495  coerceValue(myMaxedgelen, value);
496  break;
497  case 30:
498  coerceValue(myDodepth, value);
499  break;
500  case 31:
501  coerceValue(myEdgestep, value);
502  break;
503  case 32:
504  coerceValue(myEdgeptgrp, value);
505  break;
506  case 33:
507  coerceValue(myUnshared, value);
508  break;
509  case 34:
510  coerceValue(myBoundaryGroups, value);
511  break;
512 
513  }
514  }
515 
516  void setParmValue(exint idx, const exint &value)
517  { doSetParmValue(idx, value); }
518  void setParmValue(exint idx, const fpreal &value)
519  { doSetParmValue(idx, value); }
520  void setParmValue(exint idx, const UT_Vector2D &value)
521  { doSetParmValue(idx, value); }
522  void setParmValue(exint idx, const UT_Vector3D &value)
523  { doSetParmValue(idx, value); }
524  void setParmValue(exint idx, const UT_Vector4D &value)
525  { doSetParmValue(idx, value); }
526  void setParmValue(exint idx, const UT_Matrix2D &value)
527  { doSetParmValue(idx, value); }
528  void setParmValue(exint idx, const UT_Matrix3D &value)
529  { doSetParmValue(idx, value); }
530  void setParmValue(exint idx, const UT_Matrix4D &value)
531  { doSetParmValue(idx, value); }
533  { doSetParmValue(idx, value); }
535  { doSetParmValue(idx, value); }
537  { doSetParmValue(idx, value); }
538 
539  virtual exint getNumParms() const
540  {
541  return 35;
542  }
543 
544  virtual const char *getParmName(exint fieldnum) const
545  {
546  switch (fieldnum)
547  {
548  case 0:
549  return "groupname";
550  case 1:
551  return "grouptype";
552  case 2:
553  return "mergeop";
554  case 3:
555  return "groupbase";
556  case 4:
557  return "basegroup";
558  case 5:
559  return "ordered";
560  case 6:
561  return "geotype";
562  case 7:
563  return "groupbounding";
564  case 8:
565  return "boundtype";
566  case 9:
567  return "size";
568  case 10:
569  return "t";
570  case 11:
571  return "includenotwhollycontained";
572  case 12:
573  return "iso";
574  case 13:
575  return "invertvolume";
576  case 14:
577  return "groupnormal";
578  case 15:
579  return "camerapath";
580  case 16:
581  return "nonplanar";
582  case 17:
583  return "nonplanartol";
584  case 18:
585  return "dir";
586  case 19:
587  return "angle";
588  case 20:
589  return "groupedges";
590  case 21:
591  return "dominedgeangle";
592  case 22:
593  return "minedgeangle";
594  case 23:
595  return "domaxedgeangle";
596  case 24:
597  return "maxedgeangle";
598  case 25:
599  return "edgeanglebetweenedges";
600  case 26:
601  return "dominedgelen";
602  case 27:
603  return "minedgelen";
604  case 28:
605  return "domaxedgelen";
606  case 29:
607  return "maxedgelen";
608  case 30:
609  return "dodepth";
610  case 31:
611  return "edgestep";
612  case 32:
613  return "edgeptgrp";
614  case 33:
615  return "unshared";
616  case 34:
617  return "boundarygroups";
618 
619  }
620  return 0;
621  }
622 
623  virtual ParmType getParmType(exint fieldnum) const
624  {
625  switch (fieldnum)
626  {
627  case 0:
628  return PARM_STRING;
629  case 1:
630  return PARM_INTEGER;
631  case 2:
632  return PARM_INTEGER;
633  case 3:
634  return PARM_INTEGER;
635  case 4:
636  return PARM_STRING;
637  case 5:
638  return PARM_INTEGER;
639  case 6:
640  return PARM_INTEGER;
641  case 7:
642  return PARM_INTEGER;
643  case 8:
644  return PARM_INTEGER;
645  case 9:
646  return PARM_VECTOR3;
647  case 10:
648  return PARM_VECTOR3;
649  case 11:
650  return PARM_INTEGER;
651  case 12:
652  return PARM_FLOAT;
653  case 13:
654  return PARM_INTEGER;
655  case 14:
656  return PARM_INTEGER;
657  case 15:
658  return PARM_STRING;
659  case 16:
660  return PARM_INTEGER;
661  case 17:
662  return PARM_FLOAT;
663  case 18:
664  return PARM_VECTOR3;
665  case 19:
666  return PARM_FLOAT;
667  case 20:
668  return PARM_INTEGER;
669  case 21:
670  return PARM_INTEGER;
671  case 22:
672  return PARM_FLOAT;
673  case 23:
674  return PARM_INTEGER;
675  case 24:
676  return PARM_FLOAT;
677  case 25:
678  return PARM_INTEGER;
679  case 26:
680  return PARM_INTEGER;
681  case 27:
682  return PARM_FLOAT;
683  case 28:
684  return PARM_INTEGER;
685  case 29:
686  return PARM_FLOAT;
687  case 30:
688  return PARM_INTEGER;
689  case 31:
690  return PARM_INTEGER;
691  case 32:
692  return PARM_STRING;
693  case 33:
694  return PARM_INTEGER;
695  case 34:
696  return PARM_INTEGER;
697 
698  }
699  return PARM_UNSUPPORTED;
700  }
701 
702  // Boiler plate to load individual types.
703  static void loadData(UT_IStream &is, int64 &v)
704  { is.bread(&v, 1); }
705  static void loadData(UT_IStream &is, bool &v)
706  { int64 iv; is.bread(&iv, 1); v = iv; }
707  static void loadData(UT_IStream &is, fpreal64 &v)
708  { is.bread<fpreal64>(&v, 1); }
709  static void loadData(UT_IStream &is, UT_Vector2D &v)
710  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
711  static void loadData(UT_IStream &is, UT_Vector3D &v)
712  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
713  is.bread<fpreal64>(&v.z(), 1); }
714  static void loadData(UT_IStream &is, UT_Vector4D &v)
715  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
716  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
717  static void loadData(UT_IStream &is, UT_Matrix2D &v)
718  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
719  static void loadData(UT_IStream &is, UT_Matrix3D &v)
720  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
721  static void loadData(UT_IStream &is, UT_Matrix4D &v)
722  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
723  static void loadData(UT_IStream &is, UT_Vector2I &v)
724  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
725  static void loadData(UT_IStream &is, UT_Vector3I &v)
726  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
727  is.bread<int64>(&v.z(), 1); }
728  static void loadData(UT_IStream &is, UT_Vector4I &v)
729  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
730  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
732  { is.bread(v); }
734  { UT_StringHolder rampdata;
735  loadData(is, rampdata);
736  if (rampdata.isstring())
737  {
738  v.reset(new UT_Ramp());
739  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
740  v->load(istr);
741  }
742  else v.reset();
743  }
746  loadData(is, data);
747  if (data.isstring())
748  {
749  // Find the data type.
750  char *colon = UT_StringWrap(data).findChar(':');
751  if (colon)
752  {
753  int typelen = colon - data.buffer();
755  type.strncpy(data.buffer(), typelen);
756  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
757 
758  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
759  }
760  }
761  else v.reset();
762  }
763 
764  static void saveData(std::ostream &os, int64 v)
765  { UTwrite(os, &v); }
766  static void saveData(std::ostream &os, bool v)
767  { int64 iv = v; UTwrite(os, &iv); }
768  static void saveData(std::ostream &os, fpreal64 v)
769  { UTwrite<fpreal64>(os, &v); }
770  static void saveData(std::ostream &os, UT_Vector2D v)
771  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
772  static void saveData(std::ostream &os, UT_Vector3D v)
773  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
774  UTwrite<fpreal64>(os, &v.z()); }
775  static void saveData(std::ostream &os, UT_Vector4D v)
776  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
777  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
778  static void saveData(std::ostream &os, UT_Matrix2D v)
780  static void saveData(std::ostream &os, UT_Matrix3D v)
782  static void saveData(std::ostream &os, UT_Matrix4D v)
784  static void saveData(std::ostream &os, UT_StringHolder s)
785  { UT_StringWrap(s).saveBinary(os); }
786  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
787  { UT_StringHolder result;
788  UT_OStringStream ostr;
789  if (s) s->save(ostr);
790  result = ostr.str();
791  saveData(os, result);
792  }
793  static void saveData(std::ostream &os, PRM_DataItemHandle s)
794  { UT_StringHolder result;
795  UT_OStringStream ostr;
796  if (s)
797  {
798  ostr << s->getDataTypeToken();
799  ostr << ":";
800  s->saveBinary(ostr);
801  }
802  result = ostr.str();
803  saveData(os, result);
804  }
805 
806 
807  void save(std::ostream &os) const
808  {
809  int32 v = version();
810  UTwrite(os, &v);
811  saveData(os, myGroupName);
812  saveData(os, myGrouptype);
813  saveData(os, myMergeop);
814  saveData(os, myGroupBase);
815  saveData(os, myBasegroup);
816  saveData(os, myOrdered);
817  saveData(os, myGeotype);
818  saveData(os, myGroupBounding);
819  saveData(os, myBoundtype);
820  saveData(os, mySize);
821  saveData(os, myT);
822  saveData(os, myIncludenotwhollycontained);
823  saveData(os, myIso);
824  saveData(os, myInvertvolume);
825  saveData(os, myGroupNormal);
826  saveData(os, myCamerapath);
827  saveData(os, myNonplanar);
828  saveData(os, myNonplanartol);
829  saveData(os, myDir);
830  saveData(os, myAngle);
831  saveData(os, myGroupEdges);
832  saveData(os, myDominedgeangle);
833  saveData(os, myMinedgeangle);
834  saveData(os, myDomaxedgeangle);
835  saveData(os, myMaxedgeangle);
836  saveData(os, myEdgeAngleBetweenEdges);
837  saveData(os, myDominedgelen);
838  saveData(os, myMinedgelen);
839  saveData(os, myDomaxedgelen);
840  saveData(os, myMaxedgelen);
841  saveData(os, myDodepth);
842  saveData(os, myEdgestep);
843  saveData(os, myEdgeptgrp);
844  saveData(os, myUnshared);
845  saveData(os, myBoundaryGroups);
846 
847  }
848 
849  bool load(UT_IStream &is)
850  {
851  int32 v;
852  is.bread(&v, 1);
853  if (version() != v)
854  {
855  // Fail incompatible versions
856  return false;
857  }
858  loadData(is, myGroupName);
859  loadData(is, myGrouptype);
860  loadData(is, myMergeop);
861  loadData(is, myGroupBase);
862  loadData(is, myBasegroup);
863  loadData(is, myOrdered);
864  loadData(is, myGeotype);
865  loadData(is, myGroupBounding);
866  loadData(is, myBoundtype);
867  loadData(is, mySize);
868  loadData(is, myT);
869  loadData(is, myIncludenotwhollycontained);
870  loadData(is, myIso);
871  loadData(is, myInvertvolume);
872  loadData(is, myGroupNormal);
873  loadData(is, myCamerapath);
874  loadData(is, myNonplanar);
875  loadData(is, myNonplanartol);
876  loadData(is, myDir);
877  loadData(is, myAngle);
878  loadData(is, myGroupEdges);
879  loadData(is, myDominedgeangle);
880  loadData(is, myMinedgeangle);
881  loadData(is, myDomaxedgeangle);
882  loadData(is, myMaxedgeangle);
883  loadData(is, myEdgeAngleBetweenEdges);
884  loadData(is, myDominedgelen);
885  loadData(is, myMinedgelen);
886  loadData(is, myDomaxedgelen);
887  loadData(is, myMaxedgelen);
888  loadData(is, myDodepth);
889  loadData(is, myEdgestep);
890  loadData(is, myEdgeptgrp);
891  loadData(is, myUnshared);
892  loadData(is, myBoundaryGroups);
893 
894  return true;
895  }
896 
897  const UT_StringHolder & getGroupName() const { return myGroupName; }
898  void setGroupName(const UT_StringHolder & val) { myGroupName = val; }
900  {
901  SOP_Node *thissop = cookparms.getNode();
902  if (!thissop) return getGroupName();
903  UT_StringHolder result;
904  OP_Utils::evalOpParm(result, thissop, "groupname", cookparms.getCookTime(), 0);
905  return result;
906  }
907  Grouptype getGrouptype() const { return Grouptype(myGrouptype); }
908  void setGrouptype(Grouptype val) { myGrouptype = int64(val); }
910  {
911  SOP_Node *thissop = cookparms.getNode();
912  if (!thissop) return getGrouptype();
913  int64 result;
914  OP_Utils::evalOpParm(result, thissop, "grouptype", cookparms.getCookTime(), 0);
915  return Grouptype(result);
916  }
917  Mergeop getMergeop() const { return Mergeop(myMergeop); }
918  void setMergeop(Mergeop val) { myMergeop = int64(val); }
919  Mergeop opMergeop(const SOP_NodeVerb::CookParms &cookparms) const
920  {
921  SOP_Node *thissop = cookparms.getNode();
922  if (!thissop) return getMergeop();
923  int64 result;
924  OP_Utils::evalOpParm(result, thissop, "mergeop", cookparms.getCookTime(), 0);
925  return Mergeop(result);
926  }
927  bool getGroupBase() const { return myGroupBase; }
928  void setGroupBase(bool val) { myGroupBase = val; }
929  bool opGroupBase(const SOP_NodeVerb::CookParms &cookparms) const
930  {
931  SOP_Node *thissop = cookparms.getNode();
932  if (!thissop) return getGroupBase();
933  bool result;
934  OP_Utils::evalOpParm(result, thissop, "groupbase", cookparms.getCookTime(), 0);
935  return result;
936  }
937  const UT_StringHolder & getBasegroup() const { return myBasegroup; }
938  void setBasegroup(const UT_StringHolder & val) { myBasegroup = val; }
940  {
941  SOP_Node *thissop = cookparms.getNode();
942  if (!thissop) return getBasegroup();
943  UT_StringHolder result;
944  OP_Utils::evalOpParm(result, thissop, "basegroup", cookparms.getCookTime(), 0);
945  return result;
946  }
947  bool getOrdered() const { return myOrdered; }
948  void setOrdered(bool val) { myOrdered = val; }
949  bool opOrdered(const SOP_NodeVerb::CookParms &cookparms) const
950  {
951  SOP_Node *thissop = cookparms.getNode();
952  if (!thissop) return getOrdered();
953  bool result;
954  OP_Utils::evalOpParm(result, thissop, "ordered", cookparms.getCookTime(), 0);
955  return result;
956  }
957  int64 getGeotype() const { return myGeotype; }
958  void setGeotype(int64 val) { myGeotype = val; }
959  int64 opGeotype(const SOP_NodeVerb::CookParms &cookparms) const
960  {
961  SOP_Node *thissop = cookparms.getNode();
962  if (!thissop) return getGeotype();
963  int64 result;
964  OP_Utils::evalOpParm(result, thissop, "geotype", cookparms.getCookTime(), 0);
965  return result;
966  }
967  bool getGroupBounding() const { return myGroupBounding; }
968  void setGroupBounding(bool val) { myGroupBounding = val; }
969  bool opGroupBounding(const SOP_NodeVerb::CookParms &cookparms) const
970  {
971  SOP_Node *thissop = cookparms.getNode();
972  if (!thissop) return getGroupBounding();
973  bool result;
974  OP_Utils::evalOpParm(result, thissop, "groupbounding", cookparms.getCookTime(), 0);
975  return result;
976  }
977  Boundtype getBoundtype() const { return Boundtype(myBoundtype); }
978  void setBoundtype(Boundtype val) { myBoundtype = int64(val); }
980  {
981  SOP_Node *thissop = cookparms.getNode();
982  if (!thissop) return getBoundtype();
983  int64 result;
984  OP_Utils::evalOpParm(result, thissop, "boundtype", cookparms.getCookTime(), 0);
985  return Boundtype(result);
986  }
987  UT_Vector3D getSize() const { return mySize; }
988  void setSize(UT_Vector3D val) { mySize = val; }
990  {
991  SOP_Node *thissop = cookparms.getNode();
992  if (!thissop) return getSize();
993  UT_Vector3D result;
994  OP_Utils::evalOpParm(result, thissop, "size", cookparms.getCookTime(), 0);
995  return result;
996  }
997  UT_Vector3D getT() const { return myT; }
998  void setT(UT_Vector3D val) { myT = val; }
999  UT_Vector3D opT(const SOP_NodeVerb::CookParms &cookparms) const
1000  {
1001  SOP_Node *thissop = cookparms.getNode();
1002  if (!thissop) return getT();
1003  UT_Vector3D result;
1004  OP_Utils::evalOpParm(result, thissop, "t", cookparms.getCookTime(), 0);
1005  return result;
1006  }
1007  bool getIncludenotwhollycontained() const { return myIncludenotwhollycontained; }
1008  void setIncludenotwhollycontained(bool val) { myIncludenotwhollycontained = val; }
1010  {
1011  SOP_Node *thissop = cookparms.getNode();
1012  if (!thissop) return getIncludenotwhollycontained();
1013  bool result;
1014  OP_Utils::evalOpParm(result, thissop, "includenotwhollycontained", cookparms.getCookTime(), 0);
1015  return result;
1016  }
1017  fpreal64 getIso() const { return myIso; }
1018  void setIso(fpreal64 val) { myIso = val; }
1019  fpreal64 opIso(const SOP_NodeVerb::CookParms &cookparms) const
1020  {
1021  SOP_Node *thissop = cookparms.getNode();
1022  if (!thissop) return getIso();
1023  fpreal64 result;
1024  OP_Utils::evalOpParm(result, thissop, "iso", cookparms.getCookTime(), 0);
1025  return result;
1026  }
1027  bool getInvertvolume() const { return myInvertvolume; }
1028  void setInvertvolume(bool val) { myInvertvolume = val; }
1029  bool opInvertvolume(const SOP_NodeVerb::CookParms &cookparms) const
1030  {
1031  SOP_Node *thissop = cookparms.getNode();
1032  if (!thissop) return getInvertvolume();
1033  bool result;
1034  OP_Utils::evalOpParm(result, thissop, "invertvolume", cookparms.getCookTime(), 0);
1035  return result;
1036  }
1037  bool getGroupNormal() const { return myGroupNormal; }
1038  void setGroupNormal(bool val) { myGroupNormal = val; }
1039  bool opGroupNormal(const SOP_NodeVerb::CookParms &cookparms) const
1040  {
1041  SOP_Node *thissop = cookparms.getNode();
1042  if (!thissop) return getGroupNormal();
1043  bool result;
1044  OP_Utils::evalOpParm(result, thissop, "groupnormal", cookparms.getCookTime(), 0);
1045  return result;
1046  }
1047  const UT_StringHolder & getCamerapath() const { return myCamerapath; }
1048  void setCamerapath(const UT_StringHolder & val) { myCamerapath = val; }
1050  {
1051  SOP_Node *thissop = cookparms.getNode();
1052  if (!thissop) return getCamerapath();
1053  UT_StringHolder result;
1054  OP_Utils::evalOpParm(result, thissop, "camerapath", cookparms.getCookTime(), 0);
1055  return result;
1056  }
1057  bool getNonplanar() const { return myNonplanar; }
1058  void setNonplanar(bool val) { myNonplanar = val; }
1059  bool opNonplanar(const SOP_NodeVerb::CookParms &cookparms) const
1060  {
1061  SOP_Node *thissop = cookparms.getNode();
1062  if (!thissop) return getNonplanar();
1063  bool result;
1064  OP_Utils::evalOpParm(result, thissop, "nonplanar", cookparms.getCookTime(), 0);
1065  return result;
1066  }
1067  fpreal64 getNonplanartol() const { return myNonplanartol; }
1068  void setNonplanartol(fpreal64 val) { myNonplanartol = val; }
1070  {
1071  SOP_Node *thissop = cookparms.getNode();
1072  if (!thissop) return getNonplanartol();
1073  fpreal64 result;
1074  OP_Utils::evalOpParm(result, thissop, "nonplanartol", cookparms.getCookTime(), 0);
1075  return result;
1076  }
1077  UT_Vector3D getDir() const { return myDir; }
1078  void setDir(UT_Vector3D val) { myDir = val; }
1080  {
1081  SOP_Node *thissop = cookparms.getNode();
1082  if (!thissop) return getDir();
1083  UT_Vector3D result;
1084  OP_Utils::evalOpParm(result, thissop, "dir", cookparms.getCookTime(), 0);
1085  return result;
1086  }
1087  fpreal64 getAngle() const { return myAngle; }
1088  void setAngle(fpreal64 val) { myAngle = val; }
1089  fpreal64 opAngle(const SOP_NodeVerb::CookParms &cookparms) const
1090  {
1091  SOP_Node *thissop = cookparms.getNode();
1092  if (!thissop) return getAngle();
1093  fpreal64 result;
1094  OP_Utils::evalOpParm(result, thissop, "angle", cookparms.getCookTime(), 0);
1095  return result;
1096  }
1097  bool getGroupEdges() const { return myGroupEdges; }
1098  void setGroupEdges(bool val) { myGroupEdges = val; }
1099  bool opGroupEdges(const SOP_NodeVerb::CookParms &cookparms) const
1100  {
1101  SOP_Node *thissop = cookparms.getNode();
1102  if (!thissop) return getGroupEdges();
1103  bool result;
1104  OP_Utils::evalOpParm(result, thissop, "groupedges", cookparms.getCookTime(), 0);
1105  return result;
1106  }
1107  bool getDominedgeangle() const { return myDominedgeangle; }
1108  void setDominedgeangle(bool val) { myDominedgeangle = val; }
1109  bool opDominedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
1110  {
1111  SOP_Node *thissop = cookparms.getNode();
1112  if (!thissop) return getDominedgeangle();
1113  bool result;
1114  OP_Utils::evalOpParm(result, thissop, "dominedgeangle", cookparms.getCookTime(), 0);
1115  return result;
1116  }
1117  fpreal64 getMinedgeangle() const { return myMinedgeangle; }
1118  void setMinedgeangle(fpreal64 val) { myMinedgeangle = val; }
1120  {
1121  SOP_Node *thissop = cookparms.getNode();
1122  if (!thissop) return getMinedgeangle();
1123  fpreal64 result;
1124  OP_Utils::evalOpParm(result, thissop, "minedgeangle", cookparms.getCookTime(), 0);
1125  return result;
1126  }
1127  bool getDomaxedgeangle() const { return myDomaxedgeangle; }
1128  void setDomaxedgeangle(bool val) { myDomaxedgeangle = val; }
1129  bool opDomaxedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
1130  {
1131  SOP_Node *thissop = cookparms.getNode();
1132  if (!thissop) return getDomaxedgeangle();
1133  bool result;
1134  OP_Utils::evalOpParm(result, thissop, "domaxedgeangle", cookparms.getCookTime(), 0);
1135  return result;
1136  }
1137  fpreal64 getMaxedgeangle() const { return myMaxedgeangle; }
1138  void setMaxedgeangle(fpreal64 val) { myMaxedgeangle = val; }
1140  {
1141  SOP_Node *thissop = cookparms.getNode();
1142  if (!thissop) return getMaxedgeangle();
1143  fpreal64 result;
1144  OP_Utils::evalOpParm(result, thissop, "maxedgeangle", cookparms.getCookTime(), 0);
1145  return result;
1146  }
1147  bool getEdgeAngleBetweenEdges() const { return myEdgeAngleBetweenEdges; }
1148  void setEdgeAngleBetweenEdges(bool val) { myEdgeAngleBetweenEdges = val; }
1150  {
1151  SOP_Node *thissop = cookparms.getNode();
1152  if (!thissop) return getEdgeAngleBetweenEdges();
1153  bool result;
1154  OP_Utils::evalOpParm(result, thissop, "edgeanglebetweenedges", cookparms.getCookTime(), 0);
1155  return result;
1156  }
1157  bool getDominedgelen() const { return myDominedgelen; }
1158  void setDominedgelen(bool val) { myDominedgelen = val; }
1159  bool opDominedgelen(const SOP_NodeVerb::CookParms &cookparms) const
1160  {
1161  SOP_Node *thissop = cookparms.getNode();
1162  if (!thissop) return getDominedgelen();
1163  bool result;
1164  OP_Utils::evalOpParm(result, thissop, "dominedgelen", cookparms.getCookTime(), 0);
1165  return result;
1166  }
1167  fpreal64 getMinedgelen() const { return myMinedgelen; }
1168  void setMinedgelen(fpreal64 val) { myMinedgelen = val; }
1170  {
1171  SOP_Node *thissop = cookparms.getNode();
1172  if (!thissop) return getMinedgelen();
1173  fpreal64 result;
1174  OP_Utils::evalOpParm(result, thissop, "minedgelen", cookparms.getCookTime(), 0);
1175  return result;
1176  }
1177  bool getDomaxedgelen() const { return myDomaxedgelen; }
1178  void setDomaxedgelen(bool val) { myDomaxedgelen = val; }
1179  bool opDomaxedgelen(const SOP_NodeVerb::CookParms &cookparms) const
1180  {
1181  SOP_Node *thissop = cookparms.getNode();
1182  if (!thissop) return getDomaxedgelen();
1183  bool result;
1184  OP_Utils::evalOpParm(result, thissop, "domaxedgelen", cookparms.getCookTime(), 0);
1185  return result;
1186  }
1187  fpreal64 getMaxedgelen() const { return myMaxedgelen; }
1188  void setMaxedgelen(fpreal64 val) { myMaxedgelen = val; }
1190  {
1191  SOP_Node *thissop = cookparms.getNode();
1192  if (!thissop) return getMaxedgelen();
1193  fpreal64 result;
1194  OP_Utils::evalOpParm(result, thissop, "maxedgelen", cookparms.getCookTime(), 0);
1195  return result;
1196  }
1197  bool getDodepth() const { return myDodepth; }
1198  void setDodepth(bool val) { myDodepth = val; }
1199  bool opDodepth(const SOP_NodeVerb::CookParms &cookparms) const
1200  {
1201  SOP_Node *thissop = cookparms.getNode();
1202  if (!thissop) return getDodepth();
1203  bool result;
1204  OP_Utils::evalOpParm(result, thissop, "dodepth", cookparms.getCookTime(), 0);
1205  return result;
1206  }
1207  int64 getEdgestep() const { return myEdgestep; }
1208  void setEdgestep(int64 val) { myEdgestep = val; }
1209  int64 opEdgestep(const SOP_NodeVerb::CookParms &cookparms) const
1210  {
1211  SOP_Node *thissop = cookparms.getNode();
1212  if (!thissop) return getEdgestep();
1213  int64 result;
1214  OP_Utils::evalOpParm(result, thissop, "edgestep", cookparms.getCookTime(), 0);
1215  return result;
1216  }
1217  const UT_StringHolder & getEdgeptgrp() const { return myEdgeptgrp; }
1218  void setEdgeptgrp(const UT_StringHolder & val) { myEdgeptgrp = val; }
1220  {
1221  SOP_Node *thissop = cookparms.getNode();
1222  if (!thissop) return getEdgeptgrp();
1223  UT_StringHolder result;
1224  OP_Utils::evalOpParm(result, thissop, "edgeptgrp", cookparms.getCookTime(), 0);
1225  return result;
1226  }
1227  bool getUnshared() const { return myUnshared; }
1228  void setUnshared(bool val) { myUnshared = val; }
1229  bool opUnshared(const SOP_NodeVerb::CookParms &cookparms) const
1230  {
1231  SOP_Node *thissop = cookparms.getNode();
1232  if (!thissop) return getUnshared();
1233  bool result;
1234  OP_Utils::evalOpParm(result, thissop, "unshared", cookparms.getCookTime(), 0);
1235  return result;
1236  }
1237  bool getBoundaryGroups() const { return myBoundaryGroups; }
1238  void setBoundaryGroups(bool val) { myBoundaryGroups = val; }
1239  bool opBoundaryGroups(const SOP_NodeVerb::CookParms &cookparms) const
1240  {
1241  SOP_Node *thissop = cookparms.getNode();
1242  if (!thissop) return getBoundaryGroups();
1243  bool result;
1244  OP_Utils::evalOpParm(result, thissop, "boundarygroups", cookparms.getCookTime(), 0);
1245  return result;
1246  }
1247 
1248 private:
1249  UT_StringHolder myGroupName;
1250  int64 myGrouptype;
1251  int64 myMergeop;
1252  bool myGroupBase;
1253  UT_StringHolder myBasegroup;
1254  bool myOrdered;
1255  int64 myGeotype;
1256  bool myGroupBounding;
1257  int64 myBoundtype;
1258  UT_Vector3D mySize;
1259  UT_Vector3D myT;
1260  bool myIncludenotwhollycontained;
1261  fpreal64 myIso;
1262  bool myInvertvolume;
1263  bool myGroupNormal;
1264  UT_StringHolder myCamerapath;
1265  bool myNonplanar;
1266  fpreal64 myNonplanartol;
1267  UT_Vector3D myDir;
1268  fpreal64 myAngle;
1269  bool myGroupEdges;
1270  bool myDominedgeangle;
1271  fpreal64 myMinedgeangle;
1272  bool myDomaxedgeangle;
1273  fpreal64 myMaxedgeangle;
1274  bool myEdgeAngleBetweenEdges;
1275  bool myDominedgelen;
1276  fpreal64 myMinedgelen;
1277  bool myDomaxedgelen;
1278  fpreal64 myMaxedgelen;
1279  bool myDodepth;
1280  int64 myEdgestep;
1281  UT_StringHolder myEdgeptgrp;
1282  bool myUnshared;
1283  bool myBoundaryGroups;
1284 
1285 };
void setIncludenotwhollycontained(bool val)
bool getEdgeAngleBetweenEdges() const
static void saveData(std::ostream &os, UT_StringHolder s)
void setMaxedgeangle(fpreal64 val)
bool opUnshared(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getGroupName() const
static void loadData(UT_IStream &is, bool &v)
const UT_StringHolder & getCamerapath() const
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:492
void setGrouptype(Grouptype val)
void setDir(UT_Vector3D val)
T & z(void)
Definition: UT_Vector4.h:372
static void saveData(std::ostream &os, UT_Matrix4D v)
fpreal64 opMaxedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
void setBasegroup(const UT_StringHolder &val)
void setSize(UT_Vector3D val)
static void saveData(std::ostream &os, int64 v)
void setParmValue(exint idx, const UT_Vector4D &value)
exint bread(int32 *buffer, exint asize=1)
fpreal getTime() const
Definition: OP_Context.h:34
const GLdouble * v
Definition: glcorearb.h:836
UT_Vector3D opDir(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, bool v)
bool opInvertvolume(const SOP_NodeVerb::CookParms &cookparms) const
bool opDomaxedgelen(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Matrix2D &value) const
UT_StringHolder opEdgeptgrp(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, exint &value) const
static void loadData(UT_IStream &is, UT_Vector3D &v)
void setGroupName(const UT_StringHolder &val)
void setEdgeAngleBetweenEdges(bool val)
bool opDominedgelen(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix2D v)
void setMinedgeangle(fpreal64 val)
void setCamerapath(const UT_StringHolder &val)
bool operator==(const SOP_GroupCreateParms &src) const
T & x(void)
Definition: UT_Vector2.h:284
Boundtype getBoundtype() const
static void loadData(UT_IStream &is, UT_Vector4D &v)
bool opGroupEdges(const SOP_NodeVerb::CookParms &cookparms) const
An output stream object that owns its own string buffer storage.
UT_Vector3D getDir() const
void getParmValue(exint idx, UT_Matrix4D &value) const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
bool opDominedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
bool opDodepth(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Vector2D &value)
static void loadData(UT_IStream &is, UT_Vector2D &v)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
void doSetParmValue(exint idx, const T &value)
fpreal64 getNonplanartol() const
fpreal64 opIso(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void getParmValue(exint idx, UT_Vector4D &value) const
const UT_StringHolder & getEdgeptgrp() const
bool opGroupNormal(const SOP_NodeVerb::CookParms &cookparms) const
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
UT_Vector3D getSize() const
virtual void copyFrom(const SOP_NodeParms *src)
UT_Vector3D opT(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
const UT_StringHolder & getBasegroup() const
static void loadData(UT_IStream &is, UT_Vector3I &v)
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
long long int64
Definition: SYS_Types.h:100
virtual const char * getParmName(exint fieldnum) const
void setParmValue(exint idx, const PRM_DataItemHandle &value)
int64 opGeotype(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Matrix4D &value)
void setBoundtype(Boundtype val)
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
fpreal64 opMaxedgelen(const SOP_NodeVerb::CookParms &cookparms) const
bool opDomaxedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
static void loadData(UT_IStream &is, int64 &v)
int64 exint
Definition: SYS_Types.h:109
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
fpreal64 opMinedgeangle(const SOP_NodeVerb::CookParms &cookparms) const
double fpreal64
Definition: SYS_Types.h:185
void doGetParmValue(exint idx, T &value) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
virtual exint getNumParms() const
bool opGroupBounding(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Vector3D &value)
void setParmValue(exint idx, const UT_StringHolder &value)
int64 opEdgestep(const SOP_NodeVerb::CookParms &cookparms) const
bool opOrdered(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3T< fpreal64 > UT_Vector3D
virtual void loadFromOpSubclass(const LoadParms &loadparms)
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
UT_StringHolder opBasegroup(const SOP_NodeVerb::CookParms &cookparms) const
void setMinedgelen(fpreal64 val)
GLboolean * data
Definition: glcorearb.h:130
static void loadData(UT_IStream &is, UT_Matrix3D &v)
int int32
Definition: SYS_Types.h:28
static void loadData(UT_IStream &is, UT_Matrix4D &v)
T & y(void)
Definition: UT_Vector4.h:370
Grouptype opGrouptype(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector2D &value) const
void setAngle(fpreal64 val)
Boundtype opBoundtype(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector4D v)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
void getParmValue(exint idx, UT_Vector3D &value) const
bool getIncludenotwhollycontained() const
void setMaxedgelen(fpreal64 val)
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
void setParmValue(exint idx, const UT_Matrix3D &value)
void setParmValue(exint idx, const UT_Matrix2D &value)
fpreal64 getMaxedgeangle() const
static void loadData(UT_IStream &is, UT_Vector2I &v)
bool opNonplanar(const SOP_NodeVerb::CookParms &cookparms) 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)
static void loadData(UT_IStream &is, fpreal64 &v)
virtual ParmType getParmType(exint fieldnum) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
static void saveData(std::ostream &os, PRM_DataItemHandle s)
UT_StringHolder opCamerapath(const SOP_NodeVerb::CookParms &cookparms) const
void setEdgeptgrp(const UT_StringHolder &val)
UT_Vector3D getT() const
void save(std::ostream &os) const
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
fpreal64 opMinedgelen(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix2D &v)
Mergeop opMergeop(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, fpreal &value) const
void getParmValue(exint idx, UT_StringHolder &value) const
GLuint GLfloat * val
Definition: glcorearb.h:1607
#define SOP_API
Definition: SOP_API.h:10
static void saveData(std::ostream &os, UT_Vector3D v)
const char * buffer() const
fpreal64 opNonplanartol(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_StringHolder &v)
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:499
T & x(void)
Definition: UT_Vector4.h:368
void setMergeop(Mergeop val)
T & y(void)
Definition: UT_Vector2.h:286
void setParmValue(exint idx, const exint &value)
void setT(UT_Vector3D val)
GLboolean r
Definition: glcorearb.h:1221
void setNonplanartol(fpreal64 val)
T & w(void)
Definition: UT_Vector4.h:374
static void saveData(std::ostream &os, UT_Vector2D v)
void getParmValue(exint idx, PRM_DataItemHandle &value) const
void getParmValue(exint idx, UT_Matrix3D &value) const
fpreal64 opAngle(const SOP_NodeVerb::CookParms &cookparms) const
Grouptype getGrouptype() const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool opIncludenotwhollycontained(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getMinedgeangle() const
static void saveData(std::ostream &os, fpreal64 v)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
bool opBoundaryGroups(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getMaxedgelen() const
static void saveData(std::ostream &os, UT_Matrix3D v)
UT_StringHolder opGroupName(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
void setParmValue(exint idx, const fpreal &value)
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
bool opGroupBase(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opSize(const SOP_NodeVerb::CookParms &cookparms) const
bool load(UT_IStream &is)
bool opEdgeAngleBetweenEdges(const SOP_NodeVerb::CookParms &cookparms) const
GLenum src
Definition: glcorearb.h:1792
fpreal64 getMinedgelen() const