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