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