HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_PolyDoctor.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 <SOP/SOP_GraphProxy.h>
8 
9 #include <OP/OP_Utils.h>
10 #include <PRM/PRM_Parm.h>
11 #include <UT/UT_IStream.h>
12 #include <UT/UT_NTStreamUtil.h>
13 #include <UT/UT_Ramp.h>
14 #include <UT/UT_SharedPtr.h>
15 #include <UT/UT_StringHolder.h>
16 #include <UT/UT_StringStream.h>
17 #include <UT/UT_VectorTypes.h>
18 #include <SYS/SYS_Types.h>
19 
20 using namespace UT::Literal;
21 
22 class DEP_MicroNode;
23 namespace SOP_PolyDoctorEnums
24 {
25  enum class IllFormedAction
26  {
27  IGNORE = 0,
28  MARK,
29  REPAIR
30  };
31  enum class ManyEdgesAction
32  {
33  IGNORE = 0,
34  MARK,
35  REPAIR
36  };
37  enum class NonConvexAction
38  {
39  IGNORE = 0,
40  MARK,
41  REPAIR
42  };
43  enum class OverlappingAction
44  {
45  IGNORE = 0,
46  MARK,
47  REPAIR
48  };
50  {
51  IGNORE = 0,
52  MARK,
53  REPAIR
54  };
56  {
57  IGNORE = 0,
58  MARK,
59  REPAIR
60  };
62  {
63  IGNORE = 0,
64  MARK,
65  REPAIR
66  };
67  enum class NonUniformAction
68  {
69  IGNORE = 0,
70  MARK,
71  REPAIR
72  };
74  {
75  IGNORE = 0,
76  MARK,
77  REPAIR
78  };
80  {
81  IGNORE = 0,
82  MARK,
83  REPAIR
84  };
86  {
87  IGNORE = 0,
88  MARK,
89  REPAIR
90  };
92  {
93  IGNORE = 0,
94  MARK,
95  REPAIR
96  };
97 }
98 
99 
101 {
102 public:
103  static int version() { return 1; }
104 
106  {
107  myGroup = ""_sh;
108  myMaxPasses = 50;
109  myRandomSeed = 3;
110  myIllFormedAction = 2;
111  myManyEdgesAction = 2;
112  myNonConvexAction = 2;
113  myOverlappingAction = 2;
114  myPairOverlaps = false;
115  mySelfIntersectingAction = 1;
116  myThickness = 0.0001;
117  myGloballySmallAreasAction = 0;
118  myGlobalAreaThreshold = 1e-06;
119  myLocallySmallAreasAction = 0;
120  myLocalAreaThreshold = 0.01;
121  myNonUniformAction = 0;
122  myUniformityThreshold = 0.01;
123  myGloballySmallEdgesAction = 0;
124  myGlobalEdgeThreshold = 0.001;
125  myLocallySmallEdgesAction = 0;
126  myLocalEdgeThreshold = 0.3;
127  myDisconnectedPointsAction = 0;
128  myNonManifoldPointsAction = 0;
129  myIgnoreWindings = true;
130  myPreferLargeAngles = false;
131  myVisualizeMaxManifold = false;
132  myExportManifoldNumbers = false;
133  myFixWindings = false;
134  myDeleteSmallManifolds = false;
135  mySmallManifoldSize = 0;
136  myAddValidPolyAttrib = true;
137  myValidPolyAttribName = "valid_poly"_sh;
138  myAddRepairedPolyAttrib = true;
139  myRepairedPolyAttribName = "repaired_poly"_sh;
140  myAddValidPtsAttrib = true;
141  myValidPtsAttribName = "valid_pt"_sh;
142  myAddModifiedPtsAttrib = true;
143  myModifiedPtsAttribName = "modified_pt"_sh;
144  myCreateGroups = false;
145  myVisualizeInvalidPts = false;
146  myInvalidPtsColor = UT_Vector3D(0.9,0,0);
147  myVisualizeRepairedPts = false;
148  myRepairedPtsColor = UT_Vector3D(0,0,0.9);
149  myVisualizeInvalidPolys = false;
150  myInvalidPolysColor = UT_Vector3D(0.9,0,0);
151  myVisualizeRepairedPolys = false;
152  myRepairedPolysColor = UT_Vector3D(0,0,0.9);
153 
154  }
155 
156  explicit SOP_PolyDoctorParms(const SOP_PolyDoctorParms &) = default;
157 
158  ~SOP_PolyDoctorParms() override {}
159 
160  bool operator==(const SOP_PolyDoctorParms &src) const
161  {
162  if (myGroup != src.myGroup) return false;
163  if (myMaxPasses != src.myMaxPasses) return false;
164  if (myRandomSeed != src.myRandomSeed) return false;
165  if (myIllFormedAction != src.myIllFormedAction) return false;
166  if (myManyEdgesAction != src.myManyEdgesAction) return false;
167  if (myNonConvexAction != src.myNonConvexAction) return false;
168  if (myOverlappingAction != src.myOverlappingAction) return false;
169  if (myPairOverlaps != src.myPairOverlaps) return false;
170  if (mySelfIntersectingAction != src.mySelfIntersectingAction) return false;
171  if (myThickness != src.myThickness) return false;
172  if (myGloballySmallAreasAction != src.myGloballySmallAreasAction) return false;
173  if (myGlobalAreaThreshold != src.myGlobalAreaThreshold) return false;
174  if (myLocallySmallAreasAction != src.myLocallySmallAreasAction) return false;
175  if (myLocalAreaThreshold != src.myLocalAreaThreshold) return false;
176  if (myNonUniformAction != src.myNonUniformAction) return false;
177  if (myUniformityThreshold != src.myUniformityThreshold) return false;
178  if (myGloballySmallEdgesAction != src.myGloballySmallEdgesAction) return false;
179  if (myGlobalEdgeThreshold != src.myGlobalEdgeThreshold) return false;
180  if (myLocallySmallEdgesAction != src.myLocallySmallEdgesAction) return false;
181  if (myLocalEdgeThreshold != src.myLocalEdgeThreshold) return false;
182  if (myDisconnectedPointsAction != src.myDisconnectedPointsAction) return false;
183  if (myNonManifoldPointsAction != src.myNonManifoldPointsAction) return false;
184  if (myIgnoreWindings != src.myIgnoreWindings) return false;
185  if (myPreferLargeAngles != src.myPreferLargeAngles) return false;
186  if (myVisualizeMaxManifold != src.myVisualizeMaxManifold) return false;
187  if (myExportManifoldNumbers != src.myExportManifoldNumbers) return false;
188  if (myFixWindings != src.myFixWindings) return false;
189  if (myDeleteSmallManifolds != src.myDeleteSmallManifolds) return false;
190  if (mySmallManifoldSize != src.mySmallManifoldSize) return false;
191  if (myAddValidPolyAttrib != src.myAddValidPolyAttrib) return false;
192  if (myValidPolyAttribName != src.myValidPolyAttribName) return false;
193  if (myAddRepairedPolyAttrib != src.myAddRepairedPolyAttrib) return false;
194  if (myRepairedPolyAttribName != src.myRepairedPolyAttribName) return false;
195  if (myAddValidPtsAttrib != src.myAddValidPtsAttrib) return false;
196  if (myValidPtsAttribName != src.myValidPtsAttribName) return false;
197  if (myAddModifiedPtsAttrib != src.myAddModifiedPtsAttrib) return false;
198  if (myModifiedPtsAttribName != src.myModifiedPtsAttribName) return false;
199  if (myCreateGroups != src.myCreateGroups) return false;
200  if (myVisualizeInvalidPts != src.myVisualizeInvalidPts) return false;
201  if (myInvalidPtsColor != src.myInvalidPtsColor) return false;
202  if (myVisualizeRepairedPts != src.myVisualizeRepairedPts) return false;
203  if (myRepairedPtsColor != src.myRepairedPtsColor) return false;
204  if (myVisualizeInvalidPolys != src.myVisualizeInvalidPolys) return false;
205  if (myInvalidPolysColor != src.myInvalidPolysColor) return false;
206  if (myVisualizeRepairedPolys != src.myVisualizeRepairedPolys) return false;
207  if (myRepairedPolysColor != src.myRepairedPolysColor) return false;
208 
209  return true;
210  }
211  bool operator!=(const SOP_PolyDoctorParms &src) const
212  {
213  return !operator==(src);
214  }
227 
228 
229 
230  void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
231  {
232  myGroup = ""_sh;
233  if (true)
234  graph->evalOpParm(myGroup, nodeidx, "group", time, 0);
235  myMaxPasses = 50;
236  if (true)
237  graph->evalOpParm(myMaxPasses, nodeidx, "maxpasses", time, 0);
238  myRandomSeed = 3;
239  if (true)
240  graph->evalOpParm(myRandomSeed, nodeidx, "randomseed", time, 0);
241  myIllFormedAction = 2;
242  if (true)
243  graph->evalOpParm(myIllFormedAction, nodeidx, "illformed", time, 0);
244  myManyEdgesAction = 2;
245  if (true && ( (!(((int64(getIllFormedAction())==0)))) ) )
246  graph->evalOpParm(myManyEdgesAction, nodeidx, "manyedges", time, 0);
247  myNonConvexAction = 2;
248  if (true && ( (!(((int64(getIllFormedAction())==0))||((int64(getManyEdgesAction())==0)))) ) )
249  graph->evalOpParm(myNonConvexAction, nodeidx, "nonconvex", time, 0);
250  myOverlappingAction = 2;
251  if (true && ( (!(((int64(getIllFormedAction())==0)))) ) )
252  graph->evalOpParm(myOverlappingAction, nodeidx, "overlapping", time, 0);
253  myPairOverlaps = false;
254  if (true && ( (!(((int64(getIllFormedAction())==0))||((int64(getOverlappingAction())==0)))) ) )
255  graph->evalOpParm(myPairOverlaps, nodeidx, "pairoverlaps", time, 0);
256  mySelfIntersectingAction = 1;
257  if (true && ( (!(((int64(getIllFormedAction())==0))||((int64(getManyEdgesAction())==0))||((int64(getNonConvexAction())==0)))) ) )
258  graph->evalOpParm(mySelfIntersectingAction, nodeidx, "intersect", time, 0);
259  myThickness = 0.0001;
260  if (true && ( (!(((int64(getIllFormedAction())==0))||((int64(getManyEdgesAction())==0))||((int64(getNonConvexAction())==0)))) ) )
261  graph->evalOpParm(myThickness, nodeidx, "thickness", time, 0);
262  myGloballySmallAreasAction = 0;
263  if (true && ( (!(((int64(getIllFormedAction())==0)))) ) )
264  graph->evalOpParm(myGloballySmallAreasAction, nodeidx, "glosmallarea", time, 0);
265  myGlobalAreaThreshold = 1e-06;
266  if (true && ( (!(((int64(getIllFormedAction())==0)))) ) )
267  graph->evalOpParm(myGlobalAreaThreshold, nodeidx, "gloareathres", time, 0);
268  myLocallySmallAreasAction = 0;
269  if (true && ( (!(((int64(getIllFormedAction())==0)))) ) )
270  graph->evalOpParm(myLocallySmallAreasAction, nodeidx, "locsmallarea", time, 0);
271  myLocalAreaThreshold = 0.01;
272  if (true && ( (!(((int64(getIllFormedAction())==0)))) ) )
273  graph->evalOpParm(myLocalAreaThreshold, nodeidx, "locareathres", time, 0);
274  myNonUniformAction = 0;
275  if (true && ( (!(((int64(getIllFormedAction())==0))||((int64(getManyEdgesAction())==0))||((int64(getNonConvexAction())==0)))) ) )
276  graph->evalOpParm(myNonUniformAction, nodeidx, "nonuni", time, 0);
277  myUniformityThreshold = 0.01;
278  if (true && ( (!(((int64(getIllFormedAction())==0))||((int64(getManyEdgesAction())==0))||((int64(getNonConvexAction())==0)))) ) )
279  graph->evalOpParm(myUniformityThreshold, nodeidx, "unithres", time, 0);
280  myGloballySmallEdgesAction = 0;
281  if (true)
282  graph->evalOpParm(myGloballySmallEdgesAction, nodeidx, "glosmalledge", time, 0);
283  myGlobalEdgeThreshold = 0.001;
284  if (true)
285  graph->evalOpParm(myGlobalEdgeThreshold, nodeidx, "gloedgethres", time, 0);
286  myLocallySmallEdgesAction = 0;
287  if (true)
288  graph->evalOpParm(myLocallySmallEdgesAction, nodeidx, "locsmalledge", time, 0);
289  myLocalEdgeThreshold = 0.3;
290  if (true)
291  graph->evalOpParm(myLocalEdgeThreshold, nodeidx, "locedgethres", time, 0);
292  myDisconnectedPointsAction = 0;
293  if (true)
294  graph->evalOpParm(myDisconnectedPointsAction, nodeidx, "disconnectpt", time, 0);
295  myNonManifoldPointsAction = 0;
296  if (true)
297  graph->evalOpParm(myNonManifoldPointsAction, nodeidx, "nonmanifoldpt", time, 0);
298  myIgnoreWindings = true;
299  if (true)
300  graph->evalOpParm(myIgnoreWindings, nodeidx, "ignorewindings", time, 0);
301  myPreferLargeAngles = false;
302  if (true && ( (!(((int64(getNonManifoldPointsAction())!=2)))) ) )
303  graph->evalOpParm(myPreferLargeAngles, nodeidx, "preferlargeangles", time, 0);
304  myVisualizeMaxManifold = false;
305  if (true)
306  graph->evalOpParm(myVisualizeMaxManifold, nodeidx, "vismaxmanifold", time, 0);
307  myExportManifoldNumbers = false;
308  if (true)
309  graph->evalOpParm(myExportManifoldNumbers, nodeidx, "exportmanifoldnumbers", time, 0);
310  myFixWindings = false;
311  if (true)
312  graph->evalOpParm(myFixWindings, nodeidx, "fixwindings", time, 0);
313  myDeleteSmallManifolds = false;
314  if (true)
315  graph->evalOpParm(myDeleteSmallManifolds, nodeidx, "deletesmallmanifolds", time, 0);
316  mySmallManifoldSize = 0;
317  if (true && ( (!(((getDeleteSmallManifolds()==0)))) ) )
318  graph->evalOpParm(mySmallManifoldSize, nodeidx, "smallmanifoldsize", time, 0);
319  myAddValidPolyAttrib = true;
320  if (true)
321  graph->evalOpParm(myAddValidPolyAttrib, nodeidx, "usevalidpoly", time, 0);
322  myValidPolyAttribName = "valid_poly"_sh;
323  if (true)
324  graph->evalOpParm(myValidPolyAttribName, nodeidx, "validpoly", time, 0);
325  myAddRepairedPolyAttrib = true;
326  if (true)
327  graph->evalOpParm(myAddRepairedPolyAttrib, nodeidx, "userepairedpoly", time, 0);
328  myRepairedPolyAttribName = "repaired_poly"_sh;
329  if (true)
330  graph->evalOpParm(myRepairedPolyAttribName, nodeidx, "repairedpoly", time, 0);
331  myAddValidPtsAttrib = true;
332  if (true)
333  graph->evalOpParm(myAddValidPtsAttrib, nodeidx, "usevalidpts", time, 0);
334  myValidPtsAttribName = "valid_pt"_sh;
335  if (true)
336  graph->evalOpParm(myValidPtsAttribName, nodeidx, "validpts", time, 0);
337  myAddModifiedPtsAttrib = true;
338  if (true)
339  graph->evalOpParm(myAddModifiedPtsAttrib, nodeidx, "usemodifiedpts", time, 0);
340  myModifiedPtsAttribName = "modified_pt"_sh;
341  if (true)
342  graph->evalOpParm(myModifiedPtsAttribName, nodeidx, "modifiedpts", time, 0);
343  myCreateGroups = false;
344  if (true)
345  graph->evalOpParm(myCreateGroups, nodeidx, "creategrps", time, 0);
346  myVisualizeInvalidPts = false;
347  if (true)
348  graph->evalOpParm(myVisualizeInvalidPts, nodeidx, "visinvalidpts", time, 0);
349  myInvalidPtsColor = UT_Vector3D(0.9,0,0);
350  if (true && ( (!(((getVisualizeInvalidPts()==0)))) ) )
351  graph->evalOpParm(myInvalidPtsColor, nodeidx, "visinvalidptsfg", time, 0);
352  myVisualizeRepairedPts = false;
353  if (true)
354  graph->evalOpParm(myVisualizeRepairedPts, nodeidx, "visrepairedpts", time, 0);
355  myRepairedPtsColor = UT_Vector3D(0,0,0.9);
356  if (true && ( (!(((getVisualizeRepairedPts()==0)))) ) )
357  graph->evalOpParm(myRepairedPtsColor, nodeidx, "visrepairedptsfg", time, 0);
358  myVisualizeInvalidPolys = false;
359  if (true)
360  graph->evalOpParm(myVisualizeInvalidPolys, nodeidx, "visinvalidpolys", time, 0);
361  myInvalidPolysColor = UT_Vector3D(0.9,0,0);
362  if (true && ( (!(((getVisualizeInvalidPolys()==0)))) ) )
363  graph->evalOpParm(myInvalidPolysColor, nodeidx, "visinvalidpolysfg", time, 0);
364  myVisualizeRepairedPolys = false;
365  if (true)
366  graph->evalOpParm(myVisualizeRepairedPolys, nodeidx, "visrepairedpolys", time, 0);
367  myRepairedPolysColor = UT_Vector3D(0,0,0.9);
368  if (true && ( (!(((getVisualizeRepairedPolys()==0)))) ) )
369  graph->evalOpParm(myRepairedPolysColor, nodeidx, "visrepairedpolysfg", time, 0);
370 
371  }
372 
373 
374  void loadFromOpSubclass(const LoadParms &loadparms) override
375  {
376  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
377  }
378 
379 
380  void copyFrom(const SOP_NodeParms *src) override
381  {
382  *this = *((const SOP_PolyDoctorParms *)src);
383  }
384 
385  template <typename T>
386  void
387  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
388  {
389  if (idx.size() < 1)
390  return;
391  UT_ASSERT(idx.size() == instance.size()+1);
392  if (idx.size() != instance.size()+1)
393  return;
394  switch (idx[0])
395  {
396  case 0:
397  coerceValue(value, myGroup);
398  break;
399  case 1:
400  coerceValue(value, myMaxPasses);
401  break;
402  case 2:
403  coerceValue(value, myRandomSeed);
404  break;
405  case 3:
406  coerceValue(value, myIllFormedAction);
407  break;
408  case 4:
409  coerceValue(value, myManyEdgesAction);
410  break;
411  case 5:
412  coerceValue(value, myNonConvexAction);
413  break;
414  case 6:
415  coerceValue(value, myOverlappingAction);
416  break;
417  case 7:
418  coerceValue(value, myPairOverlaps);
419  break;
420  case 8:
421  coerceValue(value, mySelfIntersectingAction);
422  break;
423  case 9:
424  coerceValue(value, myThickness);
425  break;
426  case 10:
427  coerceValue(value, myGloballySmallAreasAction);
428  break;
429  case 11:
430  coerceValue(value, myGlobalAreaThreshold);
431  break;
432  case 12:
433  coerceValue(value, myLocallySmallAreasAction);
434  break;
435  case 13:
436  coerceValue(value, myLocalAreaThreshold);
437  break;
438  case 14:
439  coerceValue(value, myNonUniformAction);
440  break;
441  case 15:
442  coerceValue(value, myUniformityThreshold);
443  break;
444  case 16:
445  coerceValue(value, myGloballySmallEdgesAction);
446  break;
447  case 17:
448  coerceValue(value, myGlobalEdgeThreshold);
449  break;
450  case 18:
451  coerceValue(value, myLocallySmallEdgesAction);
452  break;
453  case 19:
454  coerceValue(value, myLocalEdgeThreshold);
455  break;
456  case 20:
457  coerceValue(value, myDisconnectedPointsAction);
458  break;
459  case 21:
460  coerceValue(value, myNonManifoldPointsAction);
461  break;
462  case 22:
463  coerceValue(value, myIgnoreWindings);
464  break;
465  case 23:
466  coerceValue(value, myPreferLargeAngles);
467  break;
468  case 24:
469  coerceValue(value, myVisualizeMaxManifold);
470  break;
471  case 25:
472  coerceValue(value, myExportManifoldNumbers);
473  break;
474  case 26:
475  coerceValue(value, myFixWindings);
476  break;
477  case 27:
478  coerceValue(value, myDeleteSmallManifolds);
479  break;
480  case 28:
481  coerceValue(value, mySmallManifoldSize);
482  break;
483  case 29:
484  coerceValue(value, myAddValidPolyAttrib);
485  break;
486  case 30:
487  coerceValue(value, myValidPolyAttribName);
488  break;
489  case 31:
490  coerceValue(value, myAddRepairedPolyAttrib);
491  break;
492  case 32:
493  coerceValue(value, myRepairedPolyAttribName);
494  break;
495  case 33:
496  coerceValue(value, myAddValidPtsAttrib);
497  break;
498  case 34:
499  coerceValue(value, myValidPtsAttribName);
500  break;
501  case 35:
502  coerceValue(value, myAddModifiedPtsAttrib);
503  break;
504  case 36:
505  coerceValue(value, myModifiedPtsAttribName);
506  break;
507  case 37:
508  coerceValue(value, myCreateGroups);
509  break;
510  case 38:
511  coerceValue(value, myVisualizeInvalidPts);
512  break;
513  case 39:
514  coerceValue(value, myInvalidPtsColor);
515  break;
516  case 40:
517  coerceValue(value, myVisualizeRepairedPts);
518  break;
519  case 41:
520  coerceValue(value, myRepairedPtsColor);
521  break;
522  case 42:
523  coerceValue(value, myVisualizeInvalidPolys);
524  break;
525  case 43:
526  coerceValue(value, myInvalidPolysColor);
527  break;
528  case 44:
529  coerceValue(value, myVisualizeRepairedPolys);
530  break;
531  case 45:
532  coerceValue(value, myRepairedPolysColor);
533  break;
534 
535  }
536  }
537 
538  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
539  { doGetParmValue(idx, instance, value); }
540  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
541  { doGetParmValue(idx, instance, value); }
542  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
543  { doGetParmValue(idx, instance, value); }
544  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
545  { doGetParmValue(idx, instance, value); }
546  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
547  { doGetParmValue(idx, instance, value); }
548  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
549  { doGetParmValue(idx, instance, value); }
550  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
551  { doGetParmValue(idx, instance, value); }
552  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
553  { doGetParmValue(idx, instance, value); }
554  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
555  { doGetParmValue(idx, instance, value); }
556  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
557  { doGetParmValue(idx, instance, value); }
558  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
559  { doGetParmValue(idx, instance, value); }
560 
561  template <typename T>
562  void
563  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
564  {
565  if (idx.size() < 1)
566  return;
567  UT_ASSERT(idx.size() == instance.size()+1);
568  if (idx.size() != instance.size()+1)
569  return;
570  switch (idx[0])
571  {
572  case 0:
573  coerceValue(myGroup, value);
574  break;
575  case 1:
576  coerceValue(myMaxPasses, value);
577  break;
578  case 2:
579  coerceValue(myRandomSeed, value);
580  break;
581  case 3:
582  coerceValue(myIllFormedAction, value);
583  break;
584  case 4:
585  coerceValue(myManyEdgesAction, value);
586  break;
587  case 5:
588  coerceValue(myNonConvexAction, value);
589  break;
590  case 6:
591  coerceValue(myOverlappingAction, value);
592  break;
593  case 7:
594  coerceValue(myPairOverlaps, value);
595  break;
596  case 8:
597  coerceValue(mySelfIntersectingAction, value);
598  break;
599  case 9:
600  coerceValue(myThickness, value);
601  break;
602  case 10:
603  coerceValue(myGloballySmallAreasAction, value);
604  break;
605  case 11:
606  coerceValue(myGlobalAreaThreshold, value);
607  break;
608  case 12:
609  coerceValue(myLocallySmallAreasAction, value);
610  break;
611  case 13:
612  coerceValue(myLocalAreaThreshold, value);
613  break;
614  case 14:
615  coerceValue(myNonUniformAction, value);
616  break;
617  case 15:
618  coerceValue(myUniformityThreshold, value);
619  break;
620  case 16:
621  coerceValue(myGloballySmallEdgesAction, value);
622  break;
623  case 17:
624  coerceValue(myGlobalEdgeThreshold, value);
625  break;
626  case 18:
627  coerceValue(myLocallySmallEdgesAction, value);
628  break;
629  case 19:
630  coerceValue(myLocalEdgeThreshold, value);
631  break;
632  case 20:
633  coerceValue(myDisconnectedPointsAction, value);
634  break;
635  case 21:
636  coerceValue(myNonManifoldPointsAction, value);
637  break;
638  case 22:
639  coerceValue(myIgnoreWindings, value);
640  break;
641  case 23:
642  coerceValue(myPreferLargeAngles, value);
643  break;
644  case 24:
645  coerceValue(myVisualizeMaxManifold, value);
646  break;
647  case 25:
648  coerceValue(myExportManifoldNumbers, value);
649  break;
650  case 26:
651  coerceValue(myFixWindings, value);
652  break;
653  case 27:
654  coerceValue(myDeleteSmallManifolds, value);
655  break;
656  case 28:
657  coerceValue(mySmallManifoldSize, value);
658  break;
659  case 29:
660  coerceValue(myAddValidPolyAttrib, value);
661  break;
662  case 30:
663  coerceValue(myValidPolyAttribName, value);
664  break;
665  case 31:
666  coerceValue(myAddRepairedPolyAttrib, value);
667  break;
668  case 32:
669  coerceValue(myRepairedPolyAttribName, value);
670  break;
671  case 33:
672  coerceValue(myAddValidPtsAttrib, value);
673  break;
674  case 34:
675  coerceValue(myValidPtsAttribName, value);
676  break;
677  case 35:
678  coerceValue(myAddModifiedPtsAttrib, value);
679  break;
680  case 36:
681  coerceValue(myModifiedPtsAttribName, value);
682  break;
683  case 37:
684  coerceValue(myCreateGroups, value);
685  break;
686  case 38:
687  coerceValue(myVisualizeInvalidPts, value);
688  break;
689  case 39:
690  coerceValue(myInvalidPtsColor, value);
691  break;
692  case 40:
693  coerceValue(myVisualizeRepairedPts, value);
694  break;
695  case 41:
696  coerceValue(myRepairedPtsColor, value);
697  break;
698  case 42:
699  coerceValue(myVisualizeInvalidPolys, value);
700  break;
701  case 43:
702  coerceValue(myInvalidPolysColor, value);
703  break;
704  case 44:
705  coerceValue(myVisualizeRepairedPolys, value);
706  break;
707  case 45:
708  coerceValue(myRepairedPolysColor, value);
709  break;
710 
711  }
712  }
713 
714  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
715  { doSetParmValue(idx, instance, value); }
716  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
717  { doSetParmValue(idx, instance, value); }
718  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
719  { doSetParmValue(idx, instance, value); }
720  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
721  { doSetParmValue(idx, instance, value); }
722  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
723  { doSetParmValue(idx, instance, value); }
724  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
725  { doSetParmValue(idx, instance, value); }
726  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
727  { doSetParmValue(idx, instance, value); }
728  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
729  { doSetParmValue(idx, instance, value); }
730  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
731  { doSetParmValue(idx, instance, value); }
732  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
733  { doSetParmValue(idx, instance, value); }
734  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
735  { doSetParmValue(idx, instance, value); }
736 
737  exint getNestNumParms(TempIndex idx) const override
738  {
739  if (idx.size() == 0)
740  return 46;
741  switch (idx[0])
742  {
743 
744  }
745  // Invalid
746  return 0;
747  }
748 
749  const char *getNestParmName(TempIndex fieldnum) const override
750  {
751  if (fieldnum.size() < 1)
752  return 0;
753  switch (fieldnum[0])
754  {
755  case 0:
756  return "group";
757  case 1:
758  return "maxpasses";
759  case 2:
760  return "randomseed";
761  case 3:
762  return "illformed";
763  case 4:
764  return "manyedges";
765  case 5:
766  return "nonconvex";
767  case 6:
768  return "overlapping";
769  case 7:
770  return "pairoverlaps";
771  case 8:
772  return "intersect";
773  case 9:
774  return "thickness";
775  case 10:
776  return "glosmallarea";
777  case 11:
778  return "gloareathres";
779  case 12:
780  return "locsmallarea";
781  case 13:
782  return "locareathres";
783  case 14:
784  return "nonuni";
785  case 15:
786  return "unithres";
787  case 16:
788  return "glosmalledge";
789  case 17:
790  return "gloedgethres";
791  case 18:
792  return "locsmalledge";
793  case 19:
794  return "locedgethres";
795  case 20:
796  return "disconnectpt";
797  case 21:
798  return "nonmanifoldpt";
799  case 22:
800  return "ignorewindings";
801  case 23:
802  return "preferlargeangles";
803  case 24:
804  return "vismaxmanifold";
805  case 25:
806  return "exportmanifoldnumbers";
807  case 26:
808  return "fixwindings";
809  case 27:
810  return "deletesmallmanifolds";
811  case 28:
812  return "smallmanifoldsize";
813  case 29:
814  return "usevalidpoly";
815  case 30:
816  return "validpoly";
817  case 31:
818  return "userepairedpoly";
819  case 32:
820  return "repairedpoly";
821  case 33:
822  return "usevalidpts";
823  case 34:
824  return "validpts";
825  case 35:
826  return "usemodifiedpts";
827  case 36:
828  return "modifiedpts";
829  case 37:
830  return "creategrps";
831  case 38:
832  return "visinvalidpts";
833  case 39:
834  return "visinvalidptsfg";
835  case 40:
836  return "visrepairedpts";
837  case 41:
838  return "visrepairedptsfg";
839  case 42:
840  return "visinvalidpolys";
841  case 43:
842  return "visinvalidpolysfg";
843  case 44:
844  return "visrepairedpolys";
845  case 45:
846  return "visrepairedpolysfg";
847 
848  }
849  return 0;
850  }
851 
852  ParmType getNestParmType(TempIndex fieldnum) const override
853  {
854  if (fieldnum.size() < 1)
855  return PARM_UNSUPPORTED;
856  switch (fieldnum[0])
857  {
858  case 0:
859  return PARM_STRING;
860  case 1:
861  return PARM_INTEGER;
862  case 2:
863  return PARM_INTEGER;
864  case 3:
865  return PARM_INTEGER;
866  case 4:
867  return PARM_INTEGER;
868  case 5:
869  return PARM_INTEGER;
870  case 6:
871  return PARM_INTEGER;
872  case 7:
873  return PARM_INTEGER;
874  case 8:
875  return PARM_INTEGER;
876  case 9:
877  return PARM_FLOAT;
878  case 10:
879  return PARM_INTEGER;
880  case 11:
881  return PARM_FLOAT;
882  case 12:
883  return PARM_INTEGER;
884  case 13:
885  return PARM_FLOAT;
886  case 14:
887  return PARM_INTEGER;
888  case 15:
889  return PARM_FLOAT;
890  case 16:
891  return PARM_INTEGER;
892  case 17:
893  return PARM_FLOAT;
894  case 18:
895  return PARM_INTEGER;
896  case 19:
897  return PARM_FLOAT;
898  case 20:
899  return PARM_INTEGER;
900  case 21:
901  return PARM_INTEGER;
902  case 22:
903  return PARM_INTEGER;
904  case 23:
905  return PARM_INTEGER;
906  case 24:
907  return PARM_INTEGER;
908  case 25:
909  return PARM_INTEGER;
910  case 26:
911  return PARM_INTEGER;
912  case 27:
913  return PARM_INTEGER;
914  case 28:
915  return PARM_INTEGER;
916  case 29:
917  return PARM_INTEGER;
918  case 30:
919  return PARM_STRING;
920  case 31:
921  return PARM_INTEGER;
922  case 32:
923  return PARM_STRING;
924  case 33:
925  return PARM_INTEGER;
926  case 34:
927  return PARM_STRING;
928  case 35:
929  return PARM_INTEGER;
930  case 36:
931  return PARM_STRING;
932  case 37:
933  return PARM_INTEGER;
934  case 38:
935  return PARM_INTEGER;
936  case 39:
937  return PARM_VECTOR3;
938  case 40:
939  return PARM_INTEGER;
940  case 41:
941  return PARM_VECTOR3;
942  case 42:
943  return PARM_INTEGER;
944  case 43:
945  return PARM_VECTOR3;
946  case 44:
947  return PARM_INTEGER;
948  case 45:
949  return PARM_VECTOR3;
950 
951  }
952  return PARM_UNSUPPORTED;
953  }
954 
955  // Boiler plate to load individual types.
956  static void loadData(UT_IStream &is, int64 &v)
957  { is.bread(&v, 1); }
958  static void loadData(UT_IStream &is, bool &v)
959  { int64 iv; is.bread(&iv, 1); v = iv; }
960  static void loadData(UT_IStream &is, fpreal64 &v)
961  { is.bread<fpreal64>(&v, 1); }
962  static void loadData(UT_IStream &is, UT_Vector2D &v)
963  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
964  static void loadData(UT_IStream &is, UT_Vector3D &v)
965  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
966  is.bread<fpreal64>(&v.z(), 1); }
967  static void loadData(UT_IStream &is, UT_Vector4D &v)
968  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
969  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
970  static void loadData(UT_IStream &is, UT_Matrix2D &v)
971  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
972  static void loadData(UT_IStream &is, UT_Matrix3D &v)
973  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
974  static void loadData(UT_IStream &is, UT_Matrix4D &v)
975  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
976  static void loadData(UT_IStream &is, UT_Vector2I &v)
977  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
978  static void loadData(UT_IStream &is, UT_Vector3I &v)
979  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
980  is.bread<int64>(&v.z(), 1); }
981  static void loadData(UT_IStream &is, UT_Vector4I &v)
982  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
983  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
985  { is.bread(v); }
987  { UT_StringHolder rampdata;
988  loadData(is, rampdata);
989  if (rampdata.isstring())
990  {
991  v.reset(new UT_Ramp());
992  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
993  v->load(istr);
994  }
995  else v.reset();
996  }
999  loadData(is, data);
1000  if (data.isstring())
1001  {
1002  // Find the data type.
1003  const char *colon = UT_StringWrap(data).findChar(':');
1004  if (colon)
1005  {
1006  int typelen = colon - data.buffer();
1008  type.strncpy(data.buffer(), typelen);
1009  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1010 
1011  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1012  }
1013  }
1014  else v.reset();
1015  }
1016 
1017  static void saveData(std::ostream &os, int64 v)
1018  { UTwrite(os, &v); }
1019  static void saveData(std::ostream &os, bool v)
1020  { int64 iv = v; UTwrite(os, &iv); }
1021  static void saveData(std::ostream &os, fpreal64 v)
1022  { UTwrite<fpreal64>(os, &v); }
1023  static void saveData(std::ostream &os, UT_Vector2D v)
1024  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1025  static void saveData(std::ostream &os, UT_Vector3D v)
1026  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1027  UTwrite<fpreal64>(os, &v.z()); }
1028  static void saveData(std::ostream &os, UT_Vector4D v)
1029  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1030  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1031  static void saveData(std::ostream &os, UT_Matrix2D v)
1033  static void saveData(std::ostream &os, UT_Matrix3D v)
1035  static void saveData(std::ostream &os, UT_Matrix4D v)
1037  static void saveData(std::ostream &os, UT_StringHolder s)
1038  { UT_StringWrap(s).saveBinary(os); }
1039  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1041  UT_OStringStream ostr;
1042  if (s) s->save(ostr);
1043  result = ostr.str();
1044  saveData(os, result);
1045  }
1046  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1048  UT_OStringStream ostr;
1049  if (s)
1050  {
1051  ostr << s->getDataTypeToken();
1052  ostr << ":";
1053  s->saveBinary(ostr);
1054  }
1055  result = ostr.str();
1056  saveData(os, result);
1057  }
1058 
1059 
1060  void save(std::ostream &os) const
1061  {
1062  int32 v = version();
1063  UTwrite(os, &v);
1064  saveData(os, myGroup);
1065  saveData(os, myMaxPasses);
1066  saveData(os, myRandomSeed);
1067  saveData(os, myIllFormedAction);
1068  saveData(os, myManyEdgesAction);
1069  saveData(os, myNonConvexAction);
1070  saveData(os, myOverlappingAction);
1071  saveData(os, myPairOverlaps);
1072  saveData(os, mySelfIntersectingAction);
1073  saveData(os, myThickness);
1074  saveData(os, myGloballySmallAreasAction);
1075  saveData(os, myGlobalAreaThreshold);
1076  saveData(os, myLocallySmallAreasAction);
1077  saveData(os, myLocalAreaThreshold);
1078  saveData(os, myNonUniformAction);
1079  saveData(os, myUniformityThreshold);
1080  saveData(os, myGloballySmallEdgesAction);
1081  saveData(os, myGlobalEdgeThreshold);
1082  saveData(os, myLocallySmallEdgesAction);
1083  saveData(os, myLocalEdgeThreshold);
1084  saveData(os, myDisconnectedPointsAction);
1085  saveData(os, myNonManifoldPointsAction);
1086  saveData(os, myIgnoreWindings);
1087  saveData(os, myPreferLargeAngles);
1088  saveData(os, myVisualizeMaxManifold);
1089  saveData(os, myExportManifoldNumbers);
1090  saveData(os, myFixWindings);
1091  saveData(os, myDeleteSmallManifolds);
1092  saveData(os, mySmallManifoldSize);
1093  saveData(os, myAddValidPolyAttrib);
1094  saveData(os, myValidPolyAttribName);
1095  saveData(os, myAddRepairedPolyAttrib);
1096  saveData(os, myRepairedPolyAttribName);
1097  saveData(os, myAddValidPtsAttrib);
1098  saveData(os, myValidPtsAttribName);
1099  saveData(os, myAddModifiedPtsAttrib);
1100  saveData(os, myModifiedPtsAttribName);
1101  saveData(os, myCreateGroups);
1102  saveData(os, myVisualizeInvalidPts);
1103  saveData(os, myInvalidPtsColor);
1104  saveData(os, myVisualizeRepairedPts);
1105  saveData(os, myRepairedPtsColor);
1106  saveData(os, myVisualizeInvalidPolys);
1107  saveData(os, myInvalidPolysColor);
1108  saveData(os, myVisualizeRepairedPolys);
1109  saveData(os, myRepairedPolysColor);
1110 
1111  }
1112 
1113  bool load(UT_IStream &is)
1114  {
1115  int32 v;
1116  is.bread(&v, 1);
1117  if (version() != v)
1118  {
1119  // Fail incompatible versions
1120  return false;
1121  }
1122  loadData(is, myGroup);
1123  loadData(is, myMaxPasses);
1124  loadData(is, myRandomSeed);
1125  loadData(is, myIllFormedAction);
1126  loadData(is, myManyEdgesAction);
1127  loadData(is, myNonConvexAction);
1128  loadData(is, myOverlappingAction);
1129  loadData(is, myPairOverlaps);
1130  loadData(is, mySelfIntersectingAction);
1131  loadData(is, myThickness);
1132  loadData(is, myGloballySmallAreasAction);
1133  loadData(is, myGlobalAreaThreshold);
1134  loadData(is, myLocallySmallAreasAction);
1135  loadData(is, myLocalAreaThreshold);
1136  loadData(is, myNonUniformAction);
1137  loadData(is, myUniformityThreshold);
1138  loadData(is, myGloballySmallEdgesAction);
1139  loadData(is, myGlobalEdgeThreshold);
1140  loadData(is, myLocallySmallEdgesAction);
1141  loadData(is, myLocalEdgeThreshold);
1142  loadData(is, myDisconnectedPointsAction);
1143  loadData(is, myNonManifoldPointsAction);
1144  loadData(is, myIgnoreWindings);
1145  loadData(is, myPreferLargeAngles);
1146  loadData(is, myVisualizeMaxManifold);
1147  loadData(is, myExportManifoldNumbers);
1148  loadData(is, myFixWindings);
1149  loadData(is, myDeleteSmallManifolds);
1150  loadData(is, mySmallManifoldSize);
1151  loadData(is, myAddValidPolyAttrib);
1152  loadData(is, myValidPolyAttribName);
1153  loadData(is, myAddRepairedPolyAttrib);
1154  loadData(is, myRepairedPolyAttribName);
1155  loadData(is, myAddValidPtsAttrib);
1156  loadData(is, myValidPtsAttribName);
1157  loadData(is, myAddModifiedPtsAttrib);
1158  loadData(is, myModifiedPtsAttribName);
1159  loadData(is, myCreateGroups);
1160  loadData(is, myVisualizeInvalidPts);
1161  loadData(is, myInvalidPtsColor);
1162  loadData(is, myVisualizeRepairedPts);
1163  loadData(is, myRepairedPtsColor);
1164  loadData(is, myVisualizeInvalidPolys);
1165  loadData(is, myInvalidPolysColor);
1166  loadData(is, myVisualizeRepairedPolys);
1167  loadData(is, myRepairedPolysColor);
1168 
1169  return true;
1170  }
1171 
1172  const UT_StringHolder & getGroup() const { return myGroup; }
1173  void setGroup(const UT_StringHolder & val) { myGroup = val; }
1175  {
1176  SOP_Node *thissop = cookparms.getNode();
1177  if (!thissop) return getGroup();
1179  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
1180  return result;
1181  }
1182  int64 getMaxPasses() const { return myMaxPasses; }
1183  void setMaxPasses(int64 val) { myMaxPasses = val; }
1185  {
1186  SOP_Node *thissop = cookparms.getNode();
1187  if (!thissop) return getMaxPasses();
1188  int64 result;
1189  OP_Utils::evalOpParm(result, thissop, "maxpasses", cookparms.getCookTime(), 0);
1190  return result;
1191  }
1192  int64 getRandomSeed() const { return myRandomSeed; }
1193  void setRandomSeed(int64 val) { myRandomSeed = val; }
1195  {
1196  SOP_Node *thissop = cookparms.getNode();
1197  if (!thissop) return getRandomSeed();
1198  int64 result;
1199  OP_Utils::evalOpParm(result, thissop, "randomseed", cookparms.getCookTime(), 0);
1200  return result;
1201  }
1202  IllFormedAction getIllFormedAction() const { return IllFormedAction(myIllFormedAction); }
1203  void setIllFormedAction(IllFormedAction val) { myIllFormedAction = int64(val); }
1205  {
1206  SOP_Node *thissop = cookparms.getNode();
1207  if (!thissop) return getIllFormedAction();
1208  int64 result;
1209  OP_Utils::evalOpParm(result, thissop, "illformed", cookparms.getCookTime(), 0);
1210  return IllFormedAction(result);
1211  }
1212  ManyEdgesAction getManyEdgesAction() const { return ManyEdgesAction(myManyEdgesAction); }
1213  void setManyEdgesAction(ManyEdgesAction val) { myManyEdgesAction = int64(val); }
1215  {
1216  SOP_Node *thissop = cookparms.getNode();
1217  if (!thissop) return getManyEdgesAction();
1218  int64 result;
1219  OP_Utils::evalOpParm(result, thissop, "manyedges", cookparms.getCookTime(), 0);
1220  return ManyEdgesAction(result);
1221  }
1222  NonConvexAction getNonConvexAction() const { return NonConvexAction(myNonConvexAction); }
1223  void setNonConvexAction(NonConvexAction val) { myNonConvexAction = int64(val); }
1225  {
1226  SOP_Node *thissop = cookparms.getNode();
1227  if (!thissop) return getNonConvexAction();
1228  int64 result;
1229  OP_Utils::evalOpParm(result, thissop, "nonconvex", cookparms.getCookTime(), 0);
1230  return NonConvexAction(result);
1231  }
1232  OverlappingAction getOverlappingAction() const { return OverlappingAction(myOverlappingAction); }
1233  void setOverlappingAction(OverlappingAction val) { myOverlappingAction = int64(val); }
1235  {
1236  SOP_Node *thissop = cookparms.getNode();
1237  if (!thissop) return getOverlappingAction();
1238  int64 result;
1239  OP_Utils::evalOpParm(result, thissop, "overlapping", cookparms.getCookTime(), 0);
1240  return OverlappingAction(result);
1241  }
1242  bool getPairOverlaps() const { return myPairOverlaps; }
1243  void setPairOverlaps(bool val) { myPairOverlaps = val; }
1244  bool opPairOverlaps(const SOP_NodeVerb::CookParms &cookparms) const
1245  {
1246  SOP_Node *thissop = cookparms.getNode();
1247  if (!thissop) return getPairOverlaps();
1248  bool result;
1249  OP_Utils::evalOpParm(result, thissop, "pairoverlaps", cookparms.getCookTime(), 0);
1250  return result;
1251  }
1252  SelfIntersectingAction getSelfIntersectingAction() const { return SelfIntersectingAction(mySelfIntersectingAction); }
1253  void setSelfIntersectingAction(SelfIntersectingAction val) { mySelfIntersectingAction = int64(val); }
1255  {
1256  SOP_Node *thissop = cookparms.getNode();
1257  if (!thissop) return getSelfIntersectingAction();
1258  int64 result;
1259  OP_Utils::evalOpParm(result, thissop, "intersect", cookparms.getCookTime(), 0);
1260  return SelfIntersectingAction(result);
1261  }
1262  fpreal64 getThickness() const { return myThickness; }
1263  void setThickness(fpreal64 val) { myThickness = val; }
1265  {
1266  SOP_Node *thissop = cookparms.getNode();
1267  if (!thissop) return getThickness();
1268  fpreal64 result;
1269  OP_Utils::evalOpParm(result, thissop, "thickness", cookparms.getCookTime(), 0);
1270  return result;
1271  }
1273  void setGloballySmallAreasAction(GloballySmallAreasAction val) { myGloballySmallAreasAction = int64(val); }
1275  {
1276  SOP_Node *thissop = cookparms.getNode();
1277  if (!thissop) return getGloballySmallAreasAction();
1278  int64 result;
1279  OP_Utils::evalOpParm(result, thissop, "glosmallarea", cookparms.getCookTime(), 0);
1280  return GloballySmallAreasAction(result);
1281  }
1282  fpreal64 getGlobalAreaThreshold() const { return myGlobalAreaThreshold; }
1283  void setGlobalAreaThreshold(fpreal64 val) { myGlobalAreaThreshold = val; }
1285  {
1286  SOP_Node *thissop = cookparms.getNode();
1287  if (!thissop) return getGlobalAreaThreshold();
1288  fpreal64 result;
1289  OP_Utils::evalOpParm(result, thissop, "gloareathres", cookparms.getCookTime(), 0);
1290  return result;
1291  }
1292  LocallySmallAreasAction getLocallySmallAreasAction() const { return LocallySmallAreasAction(myLocallySmallAreasAction); }
1293  void setLocallySmallAreasAction(LocallySmallAreasAction val) { myLocallySmallAreasAction = int64(val); }
1295  {
1296  SOP_Node *thissop = cookparms.getNode();
1297  if (!thissop) return getLocallySmallAreasAction();
1298  int64 result;
1299  OP_Utils::evalOpParm(result, thissop, "locsmallarea", cookparms.getCookTime(), 0);
1300  return LocallySmallAreasAction(result);
1301  }
1302  fpreal64 getLocalAreaThreshold() const { return myLocalAreaThreshold; }
1303  void setLocalAreaThreshold(fpreal64 val) { myLocalAreaThreshold = val; }
1305  {
1306  SOP_Node *thissop = cookparms.getNode();
1307  if (!thissop) return getLocalAreaThreshold();
1308  fpreal64 result;
1309  OP_Utils::evalOpParm(result, thissop, "locareathres", cookparms.getCookTime(), 0);
1310  return result;
1311  }
1312  NonUniformAction getNonUniformAction() const { return NonUniformAction(myNonUniformAction); }
1313  void setNonUniformAction(NonUniformAction val) { myNonUniformAction = int64(val); }
1315  {
1316  SOP_Node *thissop = cookparms.getNode();
1317  if (!thissop) return getNonUniformAction();
1318  int64 result;
1319  OP_Utils::evalOpParm(result, thissop, "nonuni", cookparms.getCookTime(), 0);
1320  return NonUniformAction(result);
1321  }
1322  fpreal64 getUniformityThreshold() const { return myUniformityThreshold; }
1323  void setUniformityThreshold(fpreal64 val) { myUniformityThreshold = val; }
1325  {
1326  SOP_Node *thissop = cookparms.getNode();
1327  if (!thissop) return getUniformityThreshold();
1328  fpreal64 result;
1329  OP_Utils::evalOpParm(result, thissop, "unithres", cookparms.getCookTime(), 0);
1330  return result;
1331  }
1333  void setGloballySmallEdgesAction(GloballySmallEdgesAction val) { myGloballySmallEdgesAction = int64(val); }
1335  {
1336  SOP_Node *thissop = cookparms.getNode();
1337  if (!thissop) return getGloballySmallEdgesAction();
1338  int64 result;
1339  OP_Utils::evalOpParm(result, thissop, "glosmalledge", cookparms.getCookTime(), 0);
1340  return GloballySmallEdgesAction(result);
1341  }
1342  fpreal64 getGlobalEdgeThreshold() const { return myGlobalEdgeThreshold; }
1343  void setGlobalEdgeThreshold(fpreal64 val) { myGlobalEdgeThreshold = val; }
1345  {
1346  SOP_Node *thissop = cookparms.getNode();
1347  if (!thissop) return getGlobalEdgeThreshold();
1348  fpreal64 result;
1349  OP_Utils::evalOpParm(result, thissop, "gloedgethres", cookparms.getCookTime(), 0);
1350  return result;
1351  }
1352  LocallySmallEdgesAction getLocallySmallEdgesAction() const { return LocallySmallEdgesAction(myLocallySmallEdgesAction); }
1353  void setLocallySmallEdgesAction(LocallySmallEdgesAction val) { myLocallySmallEdgesAction = int64(val); }
1355  {
1356  SOP_Node *thissop = cookparms.getNode();
1357  if (!thissop) return getLocallySmallEdgesAction();
1358  int64 result;
1359  OP_Utils::evalOpParm(result, thissop, "locsmalledge", cookparms.getCookTime(), 0);
1360  return LocallySmallEdgesAction(result);
1361  }
1362  fpreal64 getLocalEdgeThreshold() const { return myLocalEdgeThreshold; }
1363  void setLocalEdgeThreshold(fpreal64 val) { myLocalEdgeThreshold = val; }
1365  {
1366  SOP_Node *thissop = cookparms.getNode();
1367  if (!thissop) return getLocalEdgeThreshold();
1368  fpreal64 result;
1369  OP_Utils::evalOpParm(result, thissop, "locedgethres", cookparms.getCookTime(), 0);
1370  return result;
1371  }
1373  void setDisconnectedPointsAction(DisconnectedPointsAction val) { myDisconnectedPointsAction = int64(val); }
1375  {
1376  SOP_Node *thissop = cookparms.getNode();
1377  if (!thissop) return getDisconnectedPointsAction();
1378  int64 result;
1379  OP_Utils::evalOpParm(result, thissop, "disconnectpt", cookparms.getCookTime(), 0);
1380  return DisconnectedPointsAction(result);
1381  }
1382  NonManifoldPointsAction getNonManifoldPointsAction() const { return NonManifoldPointsAction(myNonManifoldPointsAction); }
1383  void setNonManifoldPointsAction(NonManifoldPointsAction val) { myNonManifoldPointsAction = int64(val); }
1385  {
1386  SOP_Node *thissop = cookparms.getNode();
1387  if (!thissop) return getNonManifoldPointsAction();
1388  int64 result;
1389  OP_Utils::evalOpParm(result, thissop, "nonmanifoldpt", cookparms.getCookTime(), 0);
1390  return NonManifoldPointsAction(result);
1391  }
1392  bool getIgnoreWindings() const { return myIgnoreWindings; }
1393  void setIgnoreWindings(bool val) { myIgnoreWindings = val; }
1394  bool opIgnoreWindings(const SOP_NodeVerb::CookParms &cookparms) const
1395  {
1396  SOP_Node *thissop = cookparms.getNode();
1397  if (!thissop) return getIgnoreWindings();
1398  bool result;
1399  OP_Utils::evalOpParm(result, thissop, "ignorewindings", cookparms.getCookTime(), 0);
1400  return result;
1401  }
1402  bool getPreferLargeAngles() const { return myPreferLargeAngles; }
1403  void setPreferLargeAngles(bool val) { myPreferLargeAngles = val; }
1404  bool opPreferLargeAngles(const SOP_NodeVerb::CookParms &cookparms) const
1405  {
1406  SOP_Node *thissop = cookparms.getNode();
1407  if (!thissop) return getPreferLargeAngles();
1408  bool result;
1409  OP_Utils::evalOpParm(result, thissop, "preferlargeangles", cookparms.getCookTime(), 0);
1410  return result;
1411  }
1412  bool getVisualizeMaxManifold() const { return myVisualizeMaxManifold; }
1413  void setVisualizeMaxManifold(bool val) { myVisualizeMaxManifold = val; }
1415  {
1416  SOP_Node *thissop = cookparms.getNode();
1417  if (!thissop) return getVisualizeMaxManifold();
1418  bool result;
1419  OP_Utils::evalOpParm(result, thissop, "vismaxmanifold", cookparms.getCookTime(), 0);
1420  return result;
1421  }
1422  bool getExportManifoldNumbers() const { return myExportManifoldNumbers; }
1423  void setExportManifoldNumbers(bool val) { myExportManifoldNumbers = val; }
1425  {
1426  SOP_Node *thissop = cookparms.getNode();
1427  if (!thissop) return getExportManifoldNumbers();
1428  bool result;
1429  OP_Utils::evalOpParm(result, thissop, "exportmanifoldnumbers", cookparms.getCookTime(), 0);
1430  return result;
1431  }
1432  bool getFixWindings() const { return myFixWindings; }
1433  void setFixWindings(bool val) { myFixWindings = val; }
1434  bool opFixWindings(const SOP_NodeVerb::CookParms &cookparms) const
1435  {
1436  SOP_Node *thissop = cookparms.getNode();
1437  if (!thissop) return getFixWindings();
1438  bool result;
1439  OP_Utils::evalOpParm(result, thissop, "fixwindings", cookparms.getCookTime(), 0);
1440  return result;
1441  }
1442  bool getDeleteSmallManifolds() const { return myDeleteSmallManifolds; }
1443  void setDeleteSmallManifolds(bool val) { myDeleteSmallManifolds = val; }
1445  {
1446  SOP_Node *thissop = cookparms.getNode();
1447  if (!thissop) return getDeleteSmallManifolds();
1448  bool result;
1449  OP_Utils::evalOpParm(result, thissop, "deletesmallmanifolds", cookparms.getCookTime(), 0);
1450  return result;
1451  }
1452  int64 getSmallManifoldSize() const { return mySmallManifoldSize; }
1453  void setSmallManifoldSize(int64 val) { mySmallManifoldSize = val; }
1455  {
1456  SOP_Node *thissop = cookparms.getNode();
1457  if (!thissop) return getSmallManifoldSize();
1458  int64 result;
1459  OP_Utils::evalOpParm(result, thissop, "smallmanifoldsize", cookparms.getCookTime(), 0);
1460  return result;
1461  }
1462  bool getAddValidPolyAttrib() const { return myAddValidPolyAttrib; }
1463  void setAddValidPolyAttrib(bool val) { myAddValidPolyAttrib = val; }
1464  bool opAddValidPolyAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1465  {
1466  SOP_Node *thissop = cookparms.getNode();
1467  if (!thissop) return getAddValidPolyAttrib();
1468  bool result;
1469  OP_Utils::evalOpParm(result, thissop, "usevalidpoly", cookparms.getCookTime(), 0);
1470  return result;
1471  }
1472  const UT_StringHolder & getValidPolyAttribName() const { return myValidPolyAttribName; }
1473  void setValidPolyAttribName(const UT_StringHolder & val) { myValidPolyAttribName = val; }
1475  {
1476  SOP_Node *thissop = cookparms.getNode();
1477  if (!thissop) return getValidPolyAttribName();
1479  OP_Utils::evalOpParm(result, thissop, "validpoly", cookparms.getCookTime(), 0);
1480  return result;
1481  }
1482  bool getAddRepairedPolyAttrib() const { return myAddRepairedPolyAttrib; }
1483  void setAddRepairedPolyAttrib(bool val) { myAddRepairedPolyAttrib = val; }
1485  {
1486  SOP_Node *thissop = cookparms.getNode();
1487  if (!thissop) return getAddRepairedPolyAttrib();
1488  bool result;
1489  OP_Utils::evalOpParm(result, thissop, "userepairedpoly", cookparms.getCookTime(), 0);
1490  return result;
1491  }
1492  const UT_StringHolder & getRepairedPolyAttribName() const { return myRepairedPolyAttribName; }
1493  void setRepairedPolyAttribName(const UT_StringHolder & val) { myRepairedPolyAttribName = val; }
1495  {
1496  SOP_Node *thissop = cookparms.getNode();
1497  if (!thissop) return getRepairedPolyAttribName();
1499  OP_Utils::evalOpParm(result, thissop, "repairedpoly", cookparms.getCookTime(), 0);
1500  return result;
1501  }
1502  bool getAddValidPtsAttrib() const { return myAddValidPtsAttrib; }
1503  void setAddValidPtsAttrib(bool val) { myAddValidPtsAttrib = val; }
1504  bool opAddValidPtsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1505  {
1506  SOP_Node *thissop = cookparms.getNode();
1507  if (!thissop) return getAddValidPtsAttrib();
1508  bool result;
1509  OP_Utils::evalOpParm(result, thissop, "usevalidpts", cookparms.getCookTime(), 0);
1510  return result;
1511  }
1512  const UT_StringHolder & getValidPtsAttribName() const { return myValidPtsAttribName; }
1513  void setValidPtsAttribName(const UT_StringHolder & val) { myValidPtsAttribName = val; }
1515  {
1516  SOP_Node *thissop = cookparms.getNode();
1517  if (!thissop) return getValidPtsAttribName();
1519  OP_Utils::evalOpParm(result, thissop, "validpts", cookparms.getCookTime(), 0);
1520  return result;
1521  }
1522  bool getAddModifiedPtsAttrib() const { return myAddModifiedPtsAttrib; }
1523  void setAddModifiedPtsAttrib(bool val) { myAddModifiedPtsAttrib = val; }
1525  {
1526  SOP_Node *thissop = cookparms.getNode();
1527  if (!thissop) return getAddModifiedPtsAttrib();
1528  bool result;
1529  OP_Utils::evalOpParm(result, thissop, "usemodifiedpts", cookparms.getCookTime(), 0);
1530  return result;
1531  }
1532  const UT_StringHolder & getModifiedPtsAttribName() const { return myModifiedPtsAttribName; }
1533  void setModifiedPtsAttribName(const UT_StringHolder & val) { myModifiedPtsAttribName = val; }
1535  {
1536  SOP_Node *thissop = cookparms.getNode();
1537  if (!thissop) return getModifiedPtsAttribName();
1539  OP_Utils::evalOpParm(result, thissop, "modifiedpts", cookparms.getCookTime(), 0);
1540  return result;
1541  }
1542  bool getCreateGroups() const { return myCreateGroups; }
1543  void setCreateGroups(bool val) { myCreateGroups = val; }
1544  bool opCreateGroups(const SOP_NodeVerb::CookParms &cookparms) const
1545  {
1546  SOP_Node *thissop = cookparms.getNode();
1547  if (!thissop) return getCreateGroups();
1548  bool result;
1549  OP_Utils::evalOpParm(result, thissop, "creategrps", cookparms.getCookTime(), 0);
1550  return result;
1551  }
1552  bool getVisualizeInvalidPts() const { return myVisualizeInvalidPts; }
1553  void setVisualizeInvalidPts(bool val) { myVisualizeInvalidPts = val; }
1554  bool opVisualizeInvalidPts(const SOP_NodeVerb::CookParms &cookparms) const
1555  {
1556  SOP_Node *thissop = cookparms.getNode();
1557  if (!thissop) return getVisualizeInvalidPts();
1558  bool result;
1559  OP_Utils::evalOpParm(result, thissop, "visinvalidpts", cookparms.getCookTime(), 0);
1560  return result;
1561  }
1562  UT_Vector3D getInvalidPtsColor() const { return myInvalidPtsColor; }
1563  void setInvalidPtsColor(UT_Vector3D val) { myInvalidPtsColor = val; }
1565  {
1566  SOP_Node *thissop = cookparms.getNode();
1567  if (!thissop) return getInvalidPtsColor();
1569  OP_Utils::evalOpParm(result, thissop, "visinvalidptsfg", cookparms.getCookTime(), 0);
1570  return result;
1571  }
1572  bool getVisualizeRepairedPts() const { return myVisualizeRepairedPts; }
1573  void setVisualizeRepairedPts(bool val) { myVisualizeRepairedPts = val; }
1575  {
1576  SOP_Node *thissop = cookparms.getNode();
1577  if (!thissop) return getVisualizeRepairedPts();
1578  bool result;
1579  OP_Utils::evalOpParm(result, thissop, "visrepairedpts", cookparms.getCookTime(), 0);
1580  return result;
1581  }
1582  UT_Vector3D getRepairedPtsColor() const { return myRepairedPtsColor; }
1583  void setRepairedPtsColor(UT_Vector3D val) { myRepairedPtsColor = val; }
1585  {
1586  SOP_Node *thissop = cookparms.getNode();
1587  if (!thissop) return getRepairedPtsColor();
1589  OP_Utils::evalOpParm(result, thissop, "visrepairedptsfg", cookparms.getCookTime(), 0);
1590  return result;
1591  }
1592  bool getVisualizeInvalidPolys() const { return myVisualizeInvalidPolys; }
1593  void setVisualizeInvalidPolys(bool val) { myVisualizeInvalidPolys = val; }
1595  {
1596  SOP_Node *thissop = cookparms.getNode();
1597  if (!thissop) return getVisualizeInvalidPolys();
1598  bool result;
1599  OP_Utils::evalOpParm(result, thissop, "visinvalidpolys", cookparms.getCookTime(), 0);
1600  return result;
1601  }
1602  UT_Vector3D getInvalidPolysColor() const { return myInvalidPolysColor; }
1603  void setInvalidPolysColor(UT_Vector3D val) { myInvalidPolysColor = val; }
1605  {
1606  SOP_Node *thissop = cookparms.getNode();
1607  if (!thissop) return getInvalidPolysColor();
1609  OP_Utils::evalOpParm(result, thissop, "visinvalidpolysfg", cookparms.getCookTime(), 0);
1610  return result;
1611  }
1612  bool getVisualizeRepairedPolys() const { return myVisualizeRepairedPolys; }
1613  void setVisualizeRepairedPolys(bool val) { myVisualizeRepairedPolys = val; }
1615  {
1616  SOP_Node *thissop = cookparms.getNode();
1617  if (!thissop) return getVisualizeRepairedPolys();
1618  bool result;
1619  OP_Utils::evalOpParm(result, thissop, "visrepairedpolys", cookparms.getCookTime(), 0);
1620  return result;
1621  }
1622  UT_Vector3D getRepairedPolysColor() const { return myRepairedPolysColor; }
1623  void setRepairedPolysColor(UT_Vector3D val) { myRepairedPolysColor = val; }
1625  {
1626  SOP_Node *thissop = cookparms.getNode();
1627  if (!thissop) return getRepairedPolysColor();
1629  OP_Utils::evalOpParm(result, thissop, "visrepairedpolysfg", cookparms.getCookTime(), 0);
1630  return result;
1631  }
1632 
1633 private:
1634  UT_StringHolder myGroup;
1635  int64 myMaxPasses;
1636  int64 myRandomSeed;
1637  int64 myIllFormedAction;
1638  int64 myManyEdgesAction;
1639  int64 myNonConvexAction;
1640  int64 myOverlappingAction;
1641  bool myPairOverlaps;
1642  int64 mySelfIntersectingAction;
1643  fpreal64 myThickness;
1644  int64 myGloballySmallAreasAction;
1645  fpreal64 myGlobalAreaThreshold;
1646  int64 myLocallySmallAreasAction;
1647  fpreal64 myLocalAreaThreshold;
1648  int64 myNonUniformAction;
1649  fpreal64 myUniformityThreshold;
1650  int64 myGloballySmallEdgesAction;
1651  fpreal64 myGlobalEdgeThreshold;
1652  int64 myLocallySmallEdgesAction;
1653  fpreal64 myLocalEdgeThreshold;
1654  int64 myDisconnectedPointsAction;
1655  int64 myNonManifoldPointsAction;
1656  bool myIgnoreWindings;
1657  bool myPreferLargeAngles;
1658  bool myVisualizeMaxManifold;
1659  bool myExportManifoldNumbers;
1660  bool myFixWindings;
1661  bool myDeleteSmallManifolds;
1662  int64 mySmallManifoldSize;
1663  bool myAddValidPolyAttrib;
1664  UT_StringHolder myValidPolyAttribName;
1665  bool myAddRepairedPolyAttrib;
1666  UT_StringHolder myRepairedPolyAttribName;
1667  bool myAddValidPtsAttrib;
1668  UT_StringHolder myValidPtsAttribName;
1669  bool myAddModifiedPtsAttrib;
1670  UT_StringHolder myModifiedPtsAttribName;
1671  bool myCreateGroups;
1672  bool myVisualizeInvalidPts;
1673  UT_Vector3D myInvalidPtsColor;
1674  bool myVisualizeRepairedPts;
1675  UT_Vector3D myRepairedPtsColor;
1676  bool myVisualizeInvalidPolys;
1677  UT_Vector3D myInvalidPolysColor;
1678  bool myVisualizeRepairedPolys;
1679  UT_Vector3D myRepairedPolysColor;
1680 
1681 };
GLdouble s
Definition: glew.h:1390
void copyFrom(const SOP_NodeParms *src) override
bool getVisualizeInvalidPts() const
UT_StringHolder opModifiedPtsAttribName(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getLocalEdgeThreshold() const
const UT_StringHolder & getValidPolyAttribName() const
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
void setRepairedPtsColor(UT_Vector3D val)
const UT_StringHolder & getModifiedPtsAttribName() const
GloballySmallEdgesAction opGloballySmallEdgesAction(const SOP_NodeVerb::CookParms &cookparms) const
ManyEdgesAction opManyEdgesAction(const SOP_NodeVerb::CookParms &cookparms) const
NonUniformAction opNonUniformAction(const SOP_NodeVerb::CookParms &cookparms) const
void setGlobalAreaThreshold(fpreal64 val)
exint nodeIdx() const
Definition: SOP_NodeVerb.h:114
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
GLenum src
Definition: glew.h:2410
int int32
Definition: SYS_Types.h:39
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:640
fpreal64 getGlobalEdgeThreshold() const
bool opVisualizeRepairedPts(const SOP_NodeVerb::CookParms &cookparms) const
bool load(UT_IStream &is)
SelfIntersectingAction opSelfIntersectingAction(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3D &v)
LocallySmallAreasAction getLocallySmallAreasAction() const
const char * getNestParmName(TempIndex fieldnum) const override
int64 opRandomSeed(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix2D v)
fpreal64 opUniformityThreshold(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
fpreal64 opLocalEdgeThreshold(const SOP_NodeVerb::CookParms &cookparms) const
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
bool opVisualizeRepairedPolys(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getTime() const
Definition: OP_Context.h:60
void setVisualizeMaxManifold(bool val)
bool opCreateGroups(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
LocallySmallAreasAction opLocallySmallAreasAction(const SOP_NodeVerb::CookParms &cookparms) const
GLuint const GLfloat * val
Definition: glew.h:2794
int64 opMaxPasses(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
void setAddRepairedPolyAttrib(bool val)
void setManyEdgesAction(ManyEdgesAction val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
static void loadData(UT_IStream &is, int64 &v)
const UT_StringHolder & getValidPtsAttribName() const
void setInvalidPtsColor(UT_Vector3D val)
static void saveData(std::ostream &os, fpreal64 v)
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
void setSmallManifoldSize(int64 val)
int64 exint
Definition: SYS_Types.h:125
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setGlobalEdgeThreshold(fpreal64 val)
SYS_FORCE_INLINE const char * buffer() const
DisconnectedPointsAction opDisconnectedPointsAction(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, bool v)
bool opIgnoreWindings(const SOP_NodeVerb::CookParms &cookparms) const
const SOP_GraphProxy * graph() const
Definition: SOP_NodeVerb.h:113
void setThickness(fpreal64 val)
An output stream object that owns its own string buffer storage.
fpreal64 getGlobalAreaThreshold() const
static void loadData(UT_IStream &is, UT_StringHolder &v)
void setMaxPasses(int64 val)
const GLdouble * v
Definition: glew.h:1391
static void loadData(UT_IStream &is, fpreal64 &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
void setCreateGroups(bool val)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
bool getAddValidPtsAttrib() const
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
void setGloballySmallAreasAction(GloballySmallAreasAction val)
bool getVisualizeRepairedPolys() const
GloballySmallAreasAction opGloballySmallAreasAction(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, int64 v)
bool opVisualizeInvalidPts(const SOP_NodeVerb::CookParms &cookparms) const
void setExportManifoldNumbers(bool val)
NonManifoldPointsAction opNonManifoldPointsAction(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getRepairedPolyAttribName() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
void setDeleteSmallManifolds(bool val)
void setVisualizeRepairedPolys(bool val)
void setNonConvexAction(NonConvexAction val)
fpreal64 opGlobalAreaThreshold(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getInvalidPtsColor() const
double fpreal64
Definition: SYS_Types.h:201
bool opAddModifiedPtsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
static void loadData(UT_IStream &is, UT_Vector2I &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
UT_Vector3D getRepairedPolysColor() const
bool opPreferLargeAngles(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & y()
Definition: UT_Vector3.h:513
void setNonManifoldPointsAction(NonManifoldPointsAction val)
bool getExportManifoldNumbers() const
exint length() const
bool opExportManifoldNumbers(const SOP_NodeVerb::CookParms &cookparms) const
bool getAddValidPolyAttrib() const
NonUniformAction getNonUniformAction() const
ParmType getNestParmType(TempIndex fieldnum) const override
bool opDeleteSmallManifolds(const SOP_NodeVerb::CookParms &cookparms) const
void setPreferLargeAngles(bool val)
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
GLint GLenum GLsizei GLint GLsizei const void * data
Definition: glew.h:1379
SYS_FORCE_INLINE T & z()
Definition: UT_Vector3.h:515
void setDisconnectedPointsAction(DisconnectedPointsAction val)
NonManifoldPointsAction getNonManifoldPointsAction() const
void setVisualizeInvalidPolys(bool val)
fpreal64 opGlobalEdgeThreshold(const SOP_NodeVerb::CookParms &cookparms) const
void setUniformityThreshold(fpreal64 val)
static void loadData(UT_IStream &is, UT_Vector4D &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
static void saveData(std::ostream &os, UT_Matrix3D v)
const GLfloat * c
Definition: glew.h:16296
void loadFromOpSubclass(const LoadParms &loadparms) override
NonConvexAction opNonConvexAction(const SOP_NodeVerb::CookParms &cookparms) const
void setValidPolyAttribName(const UT_StringHolder &val)
long long int64
Definition: SYS_Types.h:116
OverlappingAction opOverlappingAction(const SOP_NodeVerb::CookParms &cookparms) const
bool getVisualizeInvalidPolys() const
fpreal64 getLocalAreaThreshold() const
static void loadData(UT_IStream &is, UT_Vector3I &v)
const UT_StringHolder & getGroup() const
UT_Vector3T< fpreal64 > UT_Vector3D
void setVisualizeRepairedPts(bool val)
void setOverlappingAction(OverlappingAction val)
fpreal64 getThickness() const
bool operator!=(const SOP_PolyDoctorParms &src) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
void setModifiedPtsAttribName(const UT_StringHolder &val)
bool getAddModifiedPtsAttrib() const
bool getVisualizeMaxManifold() const
int64 opSmallManifoldSize(const SOP_NodeVerb::CookParms &cookparms) const
IllFormedAction getIllFormedAction() const
void save(std::ostream &os) const
void setAddValidPolyAttrib(bool val)
bool getPreferLargeAngles() const
void setLocallySmallEdgesAction(LocallySmallEdgesAction val)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
IllFormedAction opIllFormedAction(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getRepairedPtsColor() const
void setLocalAreaThreshold(fpreal64 val)
GT_API const UT_StringHolder version
void setLocallySmallAreasAction(LocallySmallAreasAction val)
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:121
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
static void saveData(std::ostream &os, UT_StringHolder s)
void setAddModifiedPtsAttrib(bool val)
bool opFixWindings(const SOP_NodeVerb::CookParms &cookparms) const
void setVisualizeInvalidPts(bool val)
void setSelfIntersectingAction(SelfIntersectingAction val)
UT_Vector3D getInvalidPolysColor() const
void setGloballySmallEdgesAction(GloballySmallEdgesAction val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
bool getDeleteSmallManifolds() const
static void saveData(std::ostream &os, UT_Vector2D v)
GloballySmallAreasAction getGloballySmallAreasAction() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void setRepairedPolyAttribName(const UT_StringHolder &val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
fpreal64 opLocalAreaThreshold(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 fpreal
Definition: SYS_Types.h:277
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
void setIllFormedAction(IllFormedAction val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
static void loadData(UT_IStream &is, UT_Matrix4D &v)
int64 getSmallManifoldSize() const
GLdouble GLdouble GLdouble r
Definition: glew.h:1406
void setValidPtsAttribName(const UT_StringHolder &val)
static void saveData(std::ostream &os, UT_Vector3D v)
bool getAddRepairedPolyAttrib() const
#define SOP_API
Definition: SOP_API.h:10
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
void setNonUniformAction(NonUniformAction val)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
UT_Vector3D opRepairedPolysColor(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opInvalidPtsColor(const SOP_NodeVerb::CookParms &cookparms) const
NonConvexAction getNonConvexAction() const
fpreal64 getUniformityThreshold() const
void setInvalidPolysColor(UT_Vector3D val)
SYS_FORCE_INLINE T & x()
Definition: UT_Vector3.h:511
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:654
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
bool opPairOverlaps(const SOP_NodeVerb::CookParms &cookparms) const
GLuint64EXT * result
Definition: glew.h:14007
static void saveData(std::ostream &os, UT_Vector4D v)
bool opVisualizeInvalidPolys(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opValidPtsAttribName(const SOP_NodeVerb::CookParms &cookparms) const
void setPairOverlaps(bool val)
static void loadData(UT_IStream &is, bool &v)
bool operator==(const SOP_PolyDoctorParms &src) const
const char * findChar(int c) const
Definition: UT_String.h:1367
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:135
GloballySmallEdgesAction getGloballySmallEdgesAction() const
void setIgnoreWindings(bool val)
bool opVisualizeMaxManifold(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
LocallySmallEdgesAction opLocallySmallEdgesAction(const SOP_NodeVerb::CookParms &cookparms) const
ManyEdgesAction getManyEdgesAction() const
DisconnectedPointsAction getDisconnectedPointsAction() const
UT_Vector3D opInvalidPolysColor(const SOP_NodeVerb::CookParms &cookparms) const
LocallySmallEdgesAction getLocallySmallEdgesAction() const
bool getVisualizeRepairedPts() const
fpreal64 opThickness(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix4D v)
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
UT_Vector3D opRepairedPtsColor(const SOP_NodeVerb::CookParms &cookparms) const
void setAddValidPtsAttrib(bool val)
GLsizei const GLfloat * value
Definition: glew.h:1849
OverlappingAction getOverlappingAction() const
void setRandomSeed(int64 val)
void setRepairedPolysColor(UT_Vector3D val)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
UT_StringHolder opRepairedPolyAttribName(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opValidPolyAttribName(const SOP_NodeVerb::CookParms &cookparms) const
const OP_Context & context() const
Definition: SOP_NodeVerb.h:119
SelfIntersectingAction getSelfIntersectingAction() const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:89
exint getNestNumParms(TempIndex idx) const override
void setGroup(const UT_StringHolder &val)
bool opAddRepairedPolyAttrib(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
type
Definition: core.h:528
bool opAddValidPtsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setLocalEdgeThreshold(fpreal64 val)
bool opAddValidPolyAttrib(const SOP_NodeVerb::CookParms &cookparms) const