HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_Triangulate2D-3.0.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 <SOP/SOP_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_Triangulate2D_3_0Enums
24 {
25  enum class PlanePosSrc
26  {
27  FITPLANE = 0,
28  SETPROJPLANE,
29  USEATTRIB
30  };
31 
32  SYS_FORCE_INLINE UT_StringHolder
33  getToken(PlanePosSrc enum_value)
34  {
35  using namespace UT::Literal;
36  switch (enum_value) {
37  case PlanePosSrc::FITPLANE: return "fitplane"_sh;
38  case PlanePosSrc::SETPROJPLANE: return "setprojplane"_sh;
39  case PlanePosSrc::USEATTRIB: return "useattrib"_sh;
40  default: UT_ASSERT(false); return ""_sh;
41  }
42  }
43 
44  enum class TriangleSize
45  {
46  UNRESTRICTED = 0,
47  CAPMAXAREA,
48  SETTARGETEDGELENGTH
49  };
50 
51  SYS_FORCE_INLINE UT_StringHolder
52  getToken(TriangleSize enum_value)
53  {
54  using namespace UT::Literal;
55  switch (enum_value) {
56  case TriangleSize::UNRESTRICTED: return "unrestricted"_sh;
57  case TriangleSize::CAPMAXAREA: return "capmaxarea"_sh;
58  case TriangleSize::SETTARGETEDGELENGTH: return "settargetedgelength"_sh;
59  default: UT_ASSERT(false); return ""_sh;
60  }
61  }
62 
63 }
64 
65 
66 class SOP_API SOP_Triangulate2D_3_0Parms : public SOP_NodeParms
67 {
68 public:
69  static int version() { return 1; }
70 
71  SOP_Triangulate2D_3_0Parms()
72  {
73  myPoints = ""_UTsh;
74  myPlanePosSrc = 0;
75  myOrigin = UT_Vector3D(0,0,0);
76  myDist = 0;
77  myDir = UT_Vector3D(0,1,0);
78  myPos2AttribName = ""_UTsh;
79  myUseConstrEdges = false;
80  myConstrEdges = ""_UTsh;
81  myUseConstrPolys = false;
82  myConstrPolys = ""_UTsh;
83  myIgnorePolyBridges = false;
84  myUseSilhouettePolys = false;
85  mySilhouettePolys = ""_UTsh;
86  myAllowConstrSplit = true;
87  myUseExactConstruction = false;
88  myIgnoreNonConstrPts = false;
89  myRemoveFromConvexHull = false;
90  myRemoveFromConstrPolys = false;
91  myRemoveOutsideSilhouette = false;
92  myRefine = false;
93  myAllowRefineConstrSplits = true;
94  myEncroachAngle = 180;
95  myMinAngle = 0;
96  myTriangleSize = 0;
97  myMaxArea = 10000;
98  myTargetEdgeLength = 100;
99  myMinEdgeLength = 0.0001;
100  myMaxNewPts = 5000;
101  myNumLloydSteps = 0;
102  myAllowMovingInteriorInputPts = false;
103  myRestorePos = false;
104  myKeepPrims = false;
105  myUpdateNormals = true;
106  myRemoveUnusedPts = true;
107  myRemoveDuplicatePts = true;
108  myUseConstrSplitPtsGrp = false;
109  myConstrSplitPtsGrp = "constrsplitpts"_UTsh;
110  myUseConstrdEdges = false;
111  myConstrdEdges = "constrdedges"_UTsh;
112  myRandomSeed = 5678;
113 
114  }
115 
116  explicit SOP_Triangulate2D_3_0Parms(const SOP_Triangulate2D_3_0Parms &) = default;
117  SOP_Triangulate2D_3_0Parms &operator=(const SOP_Triangulate2D_3_0Parms &) = default;
118  SOP_Triangulate2D_3_0Parms(SOP_Triangulate2D_3_0Parms &&) noexcept = default;
119  SOP_Triangulate2D_3_0Parms &operator=(SOP_Triangulate2D_3_0Parms &&) noexcept = default;
120 
121  ~SOP_Triangulate2D_3_0Parms() override {}
122 
123  bool operator==(const SOP_Triangulate2D_3_0Parms &src) const
124  {
125  if (myPoints != src.myPoints) return false;
126  if (myPlanePosSrc != src.myPlanePosSrc) return false;
127  if (myOrigin != src.myOrigin) return false;
128  if (myDist != src.myDist) return false;
129  if (myDir != src.myDir) return false;
130  if (myPos2AttribName != src.myPos2AttribName) return false;
131  if (myUseConstrEdges != src.myUseConstrEdges) return false;
132  if (myConstrEdges != src.myConstrEdges) return false;
133  if (myUseConstrPolys != src.myUseConstrPolys) return false;
134  if (myConstrPolys != src.myConstrPolys) return false;
135  if (myIgnorePolyBridges != src.myIgnorePolyBridges) return false;
136  if (myUseSilhouettePolys != src.myUseSilhouettePolys) return false;
137  if (mySilhouettePolys != src.mySilhouettePolys) return false;
138  if (myAllowConstrSplit != src.myAllowConstrSplit) return false;
139  if (myUseExactConstruction != src.myUseExactConstruction) return false;
140  if (myIgnoreNonConstrPts != src.myIgnoreNonConstrPts) return false;
141  if (myRemoveFromConvexHull != src.myRemoveFromConvexHull) return false;
142  if (myRemoveFromConstrPolys != src.myRemoveFromConstrPolys) return false;
143  if (myRemoveOutsideSilhouette != src.myRemoveOutsideSilhouette) return false;
144  if (myRefine != src.myRefine) return false;
145  if (myAllowRefineConstrSplits != src.myAllowRefineConstrSplits) return false;
146  if (myEncroachAngle != src.myEncroachAngle) return false;
147  if (myMinAngle != src.myMinAngle) return false;
148  if (myTriangleSize != src.myTriangleSize) return false;
149  if (myMaxArea != src.myMaxArea) return false;
150  if (myTargetEdgeLength != src.myTargetEdgeLength) return false;
151  if (myMinEdgeLength != src.myMinEdgeLength) return false;
152  if (myMaxNewPts != src.myMaxNewPts) return false;
153  if (myNumLloydSteps != src.myNumLloydSteps) return false;
154  if (myAllowMovingInteriorInputPts != src.myAllowMovingInteriorInputPts) return false;
155  if (myRestorePos != src.myRestorePos) return false;
156  if (myKeepPrims != src.myKeepPrims) return false;
157  if (myUpdateNormals != src.myUpdateNormals) return false;
158  if (myRemoveUnusedPts != src.myRemoveUnusedPts) return false;
159  if (myRemoveDuplicatePts != src.myRemoveDuplicatePts) return false;
160  if (myUseConstrSplitPtsGrp != src.myUseConstrSplitPtsGrp) return false;
161  if (myConstrSplitPtsGrp != src.myConstrSplitPtsGrp) return false;
162  if (myUseConstrdEdges != src.myUseConstrdEdges) return false;
163  if (myConstrdEdges != src.myConstrdEdges) return false;
164  if (myRandomSeed != src.myRandomSeed) return false;
165 
166  return true;
167  }
168  bool operator!=(const SOP_Triangulate2D_3_0Parms &src) const
169  {
170  return !operator==(src);
171  }
172  using PlanePosSrc = SOP_Triangulate2D_3_0Enums::PlanePosSrc;
173  using TriangleSize = SOP_Triangulate2D_3_0Enums::TriangleSize;
174 
175 
176 
177  void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
178  {
179  myPoints = ""_UTsh;
180  if (true)
181  graph->evalOpParm(myPoints, nodeidx, "points", time, 0);
182  myPlanePosSrc = 0;
183  if (true)
184  graph->evalOpParm(myPlanePosSrc, nodeidx, "planepossrc", time, 0);
185  myOrigin = UT_Vector3D(0,0,0);
186  if (true && ( (true&&!(((int64(getPlanePosSrc())!=1)))) ) )
187  graph->evalOpParm(myOrigin, nodeidx, "origin", time, 0);
188  myDist = 0;
189  if (true && ( (true&&!(((int64(getPlanePosSrc())!=1)))) ) )
190  graph->evalOpParm(myDist, nodeidx, "dist", time, 0);
191  myDir = UT_Vector3D(0,1,0);
192  if (true && ( (true&&!(((int64(getPlanePosSrc())!=1)))) ) )
193  graph->evalOpParm(myDir, nodeidx, "dir", time, 0);
194  myPos2AttribName = ""_UTsh;
195  if (true && ( (true&&!(((int64(getPlanePosSrc())!=2)))) ) )
196  graph->evalOpParm(myPos2AttribName, nodeidx, "pos2attrib", time, 0);
197  myUseConstrEdges = false;
198  if (true)
199  graph->evalOpParm(myUseConstrEdges, nodeidx, "useconstredges", time, 0);
200  myConstrEdges = ""_UTsh;
201  if (true && ( (true&&!(((getUseConstrEdges()==0)))) ) )
202  graph->evalOpParm(myConstrEdges, nodeidx, "constredges", time, 0);
203  myUseConstrPolys = false;
204  if (true)
205  graph->evalOpParm(myUseConstrPolys, nodeidx, "useconstrpolys", time, 0);
206  myConstrPolys = ""_UTsh;
207  if (true && ( (true&&!(((getUseConstrPolys()==0)))) ) )
208  graph->evalOpParm(myConstrPolys, nodeidx, "constrpolys", time, 0);
209  myIgnorePolyBridges = false;
210  if (true && ( (true&&!(((getUseConstrPolys()==0)))) ) )
211  graph->evalOpParm(myIgnorePolyBridges, nodeidx, "ignorepolybridges", time, 0);
212  myUseSilhouettePolys = false;
213  if (true)
214  graph->evalOpParm(myUseSilhouettePolys, nodeidx, "usesilhouettepolys", time, 0);
215  mySilhouettePolys = ""_UTsh;
216  if (true && ( (true&&!(((getUseSilhouettePolys()==0)))) ) )
217  graph->evalOpParm(mySilhouettePolys, nodeidx, "silhouettepolys", time, 0);
218  myAllowConstrSplit = true;
219  if (true)
220  graph->evalOpParm(myAllowConstrSplit, nodeidx, "allowconstrsplit", time, 0);
221  myUseExactConstruction = false;
222  if (true && ( (true&&!(((getAllowConstrSplit()==0)))) ) )
223  graph->evalOpParm(myUseExactConstruction, nodeidx, "useexactconstruction", time, 0);
224  myIgnoreNonConstrPts = false;
225  if (true && ( (true&&!(((getUseConstrEdges()==0)&&(getUseConstrPolys()==0)&&(getUseSilhouettePolys()==0)))) ) )
226  graph->evalOpParm(myIgnoreNonConstrPts, nodeidx, "ignorenonconstrpts", time, 0);
227  myRemoveFromConvexHull = false;
228  if (true && ( (true&&!(((getUseConstrEdges()==0)&&(getUseConstrPolys()==0)&&(getUseSilhouettePolys()==0)))) ) )
229  graph->evalOpParm(myRemoveFromConvexHull, nodeidx, "removefromconvexhull", time, 0);
230  myRemoveFromConstrPolys = false;
231  if (true && ( (true&&!(((getUseConstrPolys()==0)))) ) )
232  graph->evalOpParm(myRemoveFromConstrPolys, nodeidx, "removefromconstrpolys", time, 0);
233  myRemoveOutsideSilhouette = false;
234  if (true && ( (true&&!(((getUseSilhouettePolys()==0)))) ) )
235  graph->evalOpParm(myRemoveOutsideSilhouette, nodeidx, "removeoutsidesilhouette", time, 0);
236  myRefine = false;
237  if (true)
238  graph->evalOpParm(myRefine, nodeidx, "refine", time, 0);
239  myAllowRefineConstrSplits = true;
240  if (true)
241  graph->evalOpParm(myAllowRefineConstrSplits, nodeidx, "allowrefineonstrsplit", time, 0);
242  myEncroachAngle = 180;
243  if (true && ( (true&&!(((getAllowRefineConstrSplits()==1)))) ) )
244  graph->evalOpParm(myEncroachAngle, nodeidx, "encroachangle", time, 0);
245  myMinAngle = 0;
246  if (true && ( (true&&!(((getRefine()==0)))) ) )
247  graph->evalOpParm(myMinAngle, nodeidx, "minangle", time, 0);
248  myTriangleSize = 0;
249  if (true && ( (true&&!(((getRefine()==0)))) ) )
250  graph->evalOpParm(myTriangleSize, nodeidx, "trianglesize", time, 0);
251  myMaxArea = 10000;
252  if (true && ( (true&&!(((int64(getTriangleSize())!=1))||((getRefine()==0)))) ) )
253  graph->evalOpParm(myMaxArea, nodeidx, "maxarea", time, 0);
254  myTargetEdgeLength = 100;
255  if (true && ( (true&&!(((int64(getTriangleSize())!=2))||((getRefine()==0)))) ) )
256  graph->evalOpParm(myTargetEdgeLength, nodeidx, "targetedgelength", time, 0);
257  myMinEdgeLength = 0.0001;
258  if (true && ( (true&&!(((getRefine()==0)))) ) )
259  graph->evalOpParm(myMinEdgeLength, nodeidx, "minedgelength", time, 0);
260  myMaxNewPts = 5000;
261  if (true && ( (true&&!(((getRefine()==0)))) ) )
262  graph->evalOpParm(myMaxNewPts, nodeidx, "maxnewpts", time, 0);
263  myNumLloydSteps = 0;
264  if (true && ( (true&&!(((getRefine()==0)))) ) )
265  graph->evalOpParm(myNumLloydSteps, nodeidx, "lloydsteps", time, 0);
266  myAllowMovingInteriorInputPts = false;
267  if (true && ( (true&&!(((getRefine()==0))||((int64(getNumLloydSteps())==0)))) ) )
268  graph->evalOpParm(myAllowMovingInteriorInputPts, nodeidx, "allowmovinginteriorpts", time, 0);
269  myRestorePos = false;
270  if (true)
271  graph->evalOpParm(myRestorePos, nodeidx, "restorepos", time, 0);
272  myKeepPrims = false;
273  if (true)
274  graph->evalOpParm(myKeepPrims, nodeidx, "keepprims", time, 0);
275  myUpdateNormals = true;
276  if (true)
277  graph->evalOpParm(myUpdateNormals, nodeidx, "updatenmls", time, 0);
278  myRemoveUnusedPts = true;
279  if (true)
280  graph->evalOpParm(myRemoveUnusedPts, nodeidx, "removeunusedpoints", time, 0);
281  myRemoveDuplicatePts = true;
282  if (true)
283  graph->evalOpParm(myRemoveDuplicatePts, nodeidx, "removeduplicatepoints", time, 0);
284  myUseConstrSplitPtsGrp = false;
285  if (true && ( (true&&!(((getAllowConstrSplit()==0)))) ) )
286  graph->evalOpParm(myUseConstrSplitPtsGrp, nodeidx, "usecontrsplitptgrp", time, 0);
287  myConstrSplitPtsGrp = "constrsplitpts"_UTsh;
288  if (true && ( (true&&!(((getUseConstrSplitPtsGrp()==0)))) ) )
289  graph->evalOpParm(myConstrSplitPtsGrp, nodeidx, "constrsplitptgrp", time, 0);
290  myUseConstrdEdges = false;
291  if (true)
292  graph->evalOpParm(myUseConstrdEdges, nodeidx, "useconstrdedges", time, 0);
293  myConstrdEdges = "constrdedges"_UTsh;
294  if (true && ( (true&&!(((getUseConstrdEdges()==0)))) ) )
295  graph->evalOpParm(myConstrdEdges, nodeidx, "constrdedges", time, 0);
296  myRandomSeed = 5678;
297  if (true)
298  graph->evalOpParm(myRandomSeed, nodeidx, "randseed", time, 0);
299 
300  }
301 
302 
303  void loadFromOpSubclass(const LoadParms &loadparms) override
304  {
305  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
306  }
307 
308 
309  void copyFrom(const OP_NodeParms *src) override
310  {
311  *this = *((const SOP_Triangulate2D_3_0Parms *)src);
312  }
313 
314  template <typename T>
315  void
316  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
317  {
318  if (idx.size() < 1)
319  return;
320  UT_ASSERT(idx.size() == instance.size()+1);
321  if (idx.size() != instance.size()+1)
322  return;
323  switch (idx[0])
324  {
325  case 0:
326  coerceValue(value, myPoints);
327  break;
328  case 1:
329  coerceValue(value, myPlanePosSrc);
330  break;
331  case 2:
332  coerceValue(value, myOrigin);
333  break;
334  case 3:
335  coerceValue(value, myDist);
336  break;
337  case 4:
338  coerceValue(value, myDir);
339  break;
340  case 5:
341  coerceValue(value, myPos2AttribName);
342  break;
343  case 6:
344  coerceValue(value, myUseConstrEdges);
345  break;
346  case 7:
347  coerceValue(value, myConstrEdges);
348  break;
349  case 8:
350  coerceValue(value, myUseConstrPolys);
351  break;
352  case 9:
353  coerceValue(value, myConstrPolys);
354  break;
355  case 10:
356  coerceValue(value, myIgnorePolyBridges);
357  break;
358  case 11:
359  coerceValue(value, myUseSilhouettePolys);
360  break;
361  case 12:
362  coerceValue(value, mySilhouettePolys);
363  break;
364  case 13:
365  coerceValue(value, myAllowConstrSplit);
366  break;
367  case 14:
368  coerceValue(value, myUseExactConstruction);
369  break;
370  case 15:
371  coerceValue(value, myIgnoreNonConstrPts);
372  break;
373  case 16:
374  coerceValue(value, myRemoveFromConvexHull);
375  break;
376  case 17:
377  coerceValue(value, myRemoveFromConstrPolys);
378  break;
379  case 18:
380  coerceValue(value, myRemoveOutsideSilhouette);
381  break;
382  case 19:
383  coerceValue(value, myRefine);
384  break;
385  case 20:
386  coerceValue(value, myAllowRefineConstrSplits);
387  break;
388  case 21:
389  coerceValue(value, myEncroachAngle);
390  break;
391  case 22:
392  coerceValue(value, myMinAngle);
393  break;
394  case 23:
395  coerceValue(value, myTriangleSize);
396  break;
397  case 24:
398  coerceValue(value, myMaxArea);
399  break;
400  case 25:
401  coerceValue(value, myTargetEdgeLength);
402  break;
403  case 26:
404  coerceValue(value, myMinEdgeLength);
405  break;
406  case 27:
407  coerceValue(value, myMaxNewPts);
408  break;
409  case 28:
410  coerceValue(value, myNumLloydSteps);
411  break;
412  case 29:
413  coerceValue(value, myAllowMovingInteriorInputPts);
414  break;
415  case 30:
416  coerceValue(value, myRestorePos);
417  break;
418  case 31:
419  coerceValue(value, myKeepPrims);
420  break;
421  case 32:
422  coerceValue(value, myUpdateNormals);
423  break;
424  case 33:
425  coerceValue(value, myRemoveUnusedPts);
426  break;
427  case 34:
428  coerceValue(value, myRemoveDuplicatePts);
429  break;
430  case 35:
431  coerceValue(value, myUseConstrSplitPtsGrp);
432  break;
433  case 36:
434  coerceValue(value, myConstrSplitPtsGrp);
435  break;
436  case 37:
437  coerceValue(value, myUseConstrdEdges);
438  break;
439  case 38:
440  coerceValue(value, myConstrdEdges);
441  break;
442  case 39:
443  coerceValue(value, myRandomSeed);
444  break;
445 
446  }
447  }
448 
449  bool isParmColorRamp(exint idx) const override
450  {
451  switch (idx)
452  {
453 
454  }
455  return false;
456  }
457 
458  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
459  { doGetParmValue(idx, instance, value); }
460  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
461  { doGetParmValue(idx, instance, value); }
462  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
463  { doGetParmValue(idx, instance, value); }
464  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
465  { doGetParmValue(idx, instance, value); }
466  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
467  { doGetParmValue(idx, instance, value); }
468  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
469  { doGetParmValue(idx, instance, value); }
470  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
471  { doGetParmValue(idx, instance, value); }
472  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
473  { doGetParmValue(idx, instance, value); }
474  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
475  { doGetParmValue(idx, instance, value); }
476  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
477  { doGetParmValue(idx, instance, value); }
478  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
479  { doGetParmValue(idx, instance, value); }
480 
481  template <typename T>
482  void
483  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
484  {
485  if (idx.size() < 1)
486  return;
487  UT_ASSERT(idx.size() == instance.size()+1);
488  if (idx.size() != instance.size()+1)
489  return;
490  switch (idx[0])
491  {
492  case 0:
493  coerceValue(myPoints, ( ( value ) ));
494  break;
495  case 1:
496  coerceValue(myPlanePosSrc, clampMinValue(0, clampMaxValue(2, value ) ));
497  break;
498  case 2:
499  coerceValue(myOrigin, ( ( value ) ));
500  break;
501  case 3:
502  coerceValue(myDist, ( ( value ) ));
503  break;
504  case 4:
505  coerceValue(myDir, ( ( value ) ));
506  break;
507  case 5:
508  coerceValue(myPos2AttribName, ( ( value ) ));
509  break;
510  case 6:
511  coerceValue(myUseConstrEdges, ( ( value ) ));
512  break;
513  case 7:
514  coerceValue(myConstrEdges, ( ( value ) ));
515  break;
516  case 8:
517  coerceValue(myUseConstrPolys, ( ( value ) ));
518  break;
519  case 9:
520  coerceValue(myConstrPolys, ( ( value ) ));
521  break;
522  case 10:
523  coerceValue(myIgnorePolyBridges, ( ( value ) ));
524  break;
525  case 11:
526  coerceValue(myUseSilhouettePolys, ( ( value ) ));
527  break;
528  case 12:
529  coerceValue(mySilhouettePolys, ( ( value ) ));
530  break;
531  case 13:
532  coerceValue(myAllowConstrSplit, ( ( value ) ));
533  break;
534  case 14:
535  coerceValue(myUseExactConstruction, ( ( value ) ));
536  break;
537  case 15:
538  coerceValue(myIgnoreNonConstrPts, ( ( value ) ));
539  break;
540  case 16:
541  coerceValue(myRemoveFromConvexHull, ( ( value ) ));
542  break;
543  case 17:
544  coerceValue(myRemoveFromConstrPolys, ( ( value ) ));
545  break;
546  case 18:
547  coerceValue(myRemoveOutsideSilhouette, ( ( value ) ));
548  break;
549  case 19:
550  coerceValue(myRefine, ( ( value ) ));
551  break;
552  case 20:
553  coerceValue(myAllowRefineConstrSplits, ( ( value ) ));
554  break;
555  case 21:
556  coerceValue(myEncroachAngle, clampMinValue(90, clampMaxValue(180, value ) ));
557  break;
558  case 22:
559  coerceValue(myMinAngle, clampMinValue(0, ( value ) ));
560  break;
561  case 23:
562  coerceValue(myTriangleSize, clampMinValue(0, clampMaxValue(2, value ) ));
563  break;
564  case 24:
565  coerceValue(myMaxArea, clampMinValue(0.0000001, ( value ) ));
566  break;
567  case 25:
568  coerceValue(myTargetEdgeLength, clampMinValue(0.0001, ( value ) ));
569  break;
570  case 26:
571  coerceValue(myMinEdgeLength, ( ( value ) ));
572  break;
573  case 27:
574  coerceValue(myMaxNewPts, clampMinValue(0, ( value ) ));
575  break;
576  case 28:
577  coerceValue(myNumLloydSteps, clampMinValue(0, ( value ) ));
578  break;
579  case 29:
580  coerceValue(myAllowMovingInteriorInputPts, ( ( value ) ));
581  break;
582  case 30:
583  coerceValue(myRestorePos, ( ( value ) ));
584  break;
585  case 31:
586  coerceValue(myKeepPrims, ( ( value ) ));
587  break;
588  case 32:
589  coerceValue(myUpdateNormals, ( ( value ) ));
590  break;
591  case 33:
592  coerceValue(myRemoveUnusedPts, ( ( value ) ));
593  break;
594  case 34:
595  coerceValue(myRemoveDuplicatePts, ( ( value ) ));
596  break;
597  case 35:
598  coerceValue(myUseConstrSplitPtsGrp, ( ( value ) ));
599  break;
600  case 36:
601  coerceValue(myConstrSplitPtsGrp, ( ( value ) ));
602  break;
603  case 37:
604  coerceValue(myUseConstrdEdges, ( ( value ) ));
605  break;
606  case 38:
607  coerceValue(myConstrdEdges, ( ( value ) ));
608  break;
609  case 39:
610  coerceValue(myRandomSeed, ( ( value ) ));
611  break;
612 
613  }
614  }
615 
616  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
617  { doSetParmValue(idx, instance, value); }
618  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
619  { doSetParmValue(idx, instance, value); }
620  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
621  { doSetParmValue(idx, instance, value); }
622  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
623  { doSetParmValue(idx, instance, value); }
624  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
625  { doSetParmValue(idx, instance, value); }
626  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
627  { doSetParmValue(idx, instance, value); }
628  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
629  { doSetParmValue(idx, instance, value); }
630  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
631  { doSetParmValue(idx, instance, value); }
632  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
633  { doSetParmValue(idx, instance, value); }
634  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
635  { doSetParmValue(idx, instance, value); }
636  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
637  { doSetParmValue(idx, instance, value); }
638 
639  exint getNestNumParms(TempIndex idx) const override
640  {
641  if (idx.size() == 0)
642  return 40;
643  switch (idx[0])
644  {
645 
646  }
647  // Invalid
648  return 0;
649  }
650 
651  const char *getNestParmName(TempIndex fieldnum) const override
652  {
653  if (fieldnum.size() < 1)
654  return 0;
655  switch (fieldnum[0])
656  {
657  case 0:
658  return "points";
659  case 1:
660  return "planepossrc";
661  case 2:
662  return "origin";
663  case 3:
664  return "dist";
665  case 4:
666  return "dir";
667  case 5:
668  return "pos2attrib";
669  case 6:
670  return "useconstredges";
671  case 7:
672  return "constredges";
673  case 8:
674  return "useconstrpolys";
675  case 9:
676  return "constrpolys";
677  case 10:
678  return "ignorepolybridges";
679  case 11:
680  return "usesilhouettepolys";
681  case 12:
682  return "silhouettepolys";
683  case 13:
684  return "allowconstrsplit";
685  case 14:
686  return "useexactconstruction";
687  case 15:
688  return "ignorenonconstrpts";
689  case 16:
690  return "removefromconvexhull";
691  case 17:
692  return "removefromconstrpolys";
693  case 18:
694  return "removeoutsidesilhouette";
695  case 19:
696  return "refine";
697  case 20:
698  return "allowrefineonstrsplit";
699  case 21:
700  return "encroachangle";
701  case 22:
702  return "minangle";
703  case 23:
704  return "trianglesize";
705  case 24:
706  return "maxarea";
707  case 25:
708  return "targetedgelength";
709  case 26:
710  return "minedgelength";
711  case 27:
712  return "maxnewpts";
713  case 28:
714  return "lloydsteps";
715  case 29:
716  return "allowmovinginteriorpts";
717  case 30:
718  return "restorepos";
719  case 31:
720  return "keepprims";
721  case 32:
722  return "updatenmls";
723  case 33:
724  return "removeunusedpoints";
725  case 34:
726  return "removeduplicatepoints";
727  case 35:
728  return "usecontrsplitptgrp";
729  case 36:
730  return "constrsplitptgrp";
731  case 37:
732  return "useconstrdedges";
733  case 38:
734  return "constrdedges";
735  case 39:
736  return "randseed";
737 
738  }
739  return 0;
740  }
741 
742  ParmType getNestParmType(TempIndex fieldnum) const override
743  {
744  if (fieldnum.size() < 1)
745  return PARM_UNSUPPORTED;
746  switch (fieldnum[0])
747  {
748  case 0:
749  return PARM_STRING;
750  case 1:
751  return PARM_INTEGER;
752  case 2:
753  return PARM_VECTOR3;
754  case 3:
755  return PARM_FLOAT;
756  case 4:
757  return PARM_VECTOR3;
758  case 5:
759  return PARM_STRING;
760  case 6:
761  return PARM_INTEGER;
762  case 7:
763  return PARM_STRING;
764  case 8:
765  return PARM_INTEGER;
766  case 9:
767  return PARM_STRING;
768  case 10:
769  return PARM_INTEGER;
770  case 11:
771  return PARM_INTEGER;
772  case 12:
773  return PARM_STRING;
774  case 13:
775  return PARM_INTEGER;
776  case 14:
777  return PARM_INTEGER;
778  case 15:
779  return PARM_INTEGER;
780  case 16:
781  return PARM_INTEGER;
782  case 17:
783  return PARM_INTEGER;
784  case 18:
785  return PARM_INTEGER;
786  case 19:
787  return PARM_INTEGER;
788  case 20:
789  return PARM_INTEGER;
790  case 21:
791  return PARM_FLOAT;
792  case 22:
793  return PARM_FLOAT;
794  case 23:
795  return PARM_INTEGER;
796  case 24:
797  return PARM_FLOAT;
798  case 25:
799  return PARM_FLOAT;
800  case 26:
801  return PARM_FLOAT;
802  case 27:
803  return PARM_INTEGER;
804  case 28:
805  return PARM_INTEGER;
806  case 29:
807  return PARM_INTEGER;
808  case 30:
809  return PARM_INTEGER;
810  case 31:
811  return PARM_INTEGER;
812  case 32:
813  return PARM_INTEGER;
814  case 33:
815  return PARM_INTEGER;
816  case 34:
817  return PARM_INTEGER;
818  case 35:
819  return PARM_INTEGER;
820  case 36:
821  return PARM_STRING;
822  case 37:
823  return PARM_INTEGER;
824  case 38:
825  return PARM_STRING;
826  case 39:
827  return PARM_INTEGER;
828 
829  }
830  return PARM_UNSUPPORTED;
831  }
832 
833  // Boiler plate to load individual types.
834  static void loadData(UT_IStream &is, int64 &v)
835  { is.bread(&v, 1); }
836  static void loadData(UT_IStream &is, bool &v)
837  { int64 iv; is.bread(&iv, 1); v = iv; }
838  static void loadData(UT_IStream &is, fpreal64 &v)
839  { is.bread<fpreal64>(&v, 1); }
840  static void loadData(UT_IStream &is, UT_Vector2D &v)
841  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
842  static void loadData(UT_IStream &is, UT_Vector3D &v)
843  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
844  is.bread<fpreal64>(&v.z(), 1); }
845  static void loadData(UT_IStream &is, UT_Vector4D &v)
846  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
847  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
848  static void loadData(UT_IStream &is, UT_Matrix2D &v)
849  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
850  static void loadData(UT_IStream &is, UT_Matrix3D &v)
851  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
852  static void loadData(UT_IStream &is, UT_Matrix4D &v)
853  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
854  static void loadData(UT_IStream &is, UT_Vector2I &v)
855  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
856  static void loadData(UT_IStream &is, UT_Vector3I &v)
857  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
858  is.bread<int64>(&v.z(), 1); }
859  static void loadData(UT_IStream &is, UT_Vector4I &v)
860  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
861  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
862  static void loadData(UT_IStream &is, UT_StringHolder &v)
863  { is.bread(v); }
864  static void loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
865  { UT_StringHolder rampdata;
866  loadData(is, rampdata);
867  if (rampdata.isstring())
868  {
869  v.reset(new UT_Ramp());
870  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
871  v->load(istr);
872  }
873  else v.reset();
874  }
875  static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
876  { UT_StringHolder data;
877  loadData(is, data);
878  if (data.isstring())
879  {
880  // Find the data type.
881  const char *colon = UT_StringWrap(data).findChar(':');
882  if (colon)
883  {
884  int typelen = colon - data.buffer();
885  UT_WorkBuffer type;
886  type.strncpy(data.buffer(), typelen);
887  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
888 
889  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
890  }
891  }
892  else v.reset();
893  }
894 
895  static void saveData(std::ostream &os, int64 v)
896  { UTwrite(os, &v); }
897  static void saveData(std::ostream &os, bool v)
898  { int64 iv = v; UTwrite(os, &iv); }
899  static void saveData(std::ostream &os, fpreal64 v)
900  { UTwrite<fpreal64>(os, &v); }
901  static void saveData(std::ostream &os, UT_Vector2D v)
902  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
903  static void saveData(std::ostream &os, UT_Vector3D v)
904  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
905  UTwrite<fpreal64>(os, &v.z()); }
906  static void saveData(std::ostream &os, UT_Vector4D v)
907  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
908  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
909  static void saveData(std::ostream &os, UT_Matrix2D v)
910  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
911  static void saveData(std::ostream &os, UT_Matrix3D v)
912  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
913  static void saveData(std::ostream &os, UT_Matrix4D v)
914  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
915  static void saveData(std::ostream &os, UT_StringHolder s)
916  { UT_StringWrap(s).saveBinary(os); }
917  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
918  { UT_StringHolder result;
919  UT_OStringStream ostr;
920  if (s) s->save(ostr);
921  result = ostr.str();
922  saveData(os, result);
923  }
924  static void saveData(std::ostream &os, PRM_DataItemHandle s)
925  { UT_StringHolder result;
926  UT_OStringStream ostr;
927  if (s)
928  {
929  ostr << s->getDataTypeToken();
930  ostr << ":";
931  s->saveBinary(ostr);
932  }
933  result = ostr.str();
934  saveData(os, result);
935  }
936 
937 
938  void save(std::ostream &os) const
939  {
940  int32 v = version();
941  UTwrite(os, &v);
942  saveData(os, myPoints);
943  saveData(os, myPlanePosSrc);
944  saveData(os, myOrigin);
945  saveData(os, myDist);
946  saveData(os, myDir);
947  saveData(os, myPos2AttribName);
948  saveData(os, myUseConstrEdges);
949  saveData(os, myConstrEdges);
950  saveData(os, myUseConstrPolys);
951  saveData(os, myConstrPolys);
952  saveData(os, myIgnorePolyBridges);
953  saveData(os, myUseSilhouettePolys);
954  saveData(os, mySilhouettePolys);
955  saveData(os, myAllowConstrSplit);
956  saveData(os, myUseExactConstruction);
957  saveData(os, myIgnoreNonConstrPts);
958  saveData(os, myRemoveFromConvexHull);
959  saveData(os, myRemoveFromConstrPolys);
960  saveData(os, myRemoveOutsideSilhouette);
961  saveData(os, myRefine);
962  saveData(os, myAllowRefineConstrSplits);
963  saveData(os, myEncroachAngle);
964  saveData(os, myMinAngle);
965  saveData(os, myTriangleSize);
966  saveData(os, myMaxArea);
967  saveData(os, myTargetEdgeLength);
968  saveData(os, myMinEdgeLength);
969  saveData(os, myMaxNewPts);
970  saveData(os, myNumLloydSteps);
971  saveData(os, myAllowMovingInteriorInputPts);
972  saveData(os, myRestorePos);
973  saveData(os, myKeepPrims);
974  saveData(os, myUpdateNormals);
975  saveData(os, myRemoveUnusedPts);
976  saveData(os, myRemoveDuplicatePts);
977  saveData(os, myUseConstrSplitPtsGrp);
978  saveData(os, myConstrSplitPtsGrp);
979  saveData(os, myUseConstrdEdges);
980  saveData(os, myConstrdEdges);
981  saveData(os, myRandomSeed);
982 
983  }
984 
985  bool load(UT_IStream &is)
986  {
987  int32 v;
988  is.bread(&v, 1);
989  if (version() != v)
990  {
991  // Fail incompatible versions
992  return false;
993  }
994  loadData(is, myPoints);
995  loadData(is, myPlanePosSrc);
996  loadData(is, myOrigin);
997  loadData(is, myDist);
998  loadData(is, myDir);
999  loadData(is, myPos2AttribName);
1000  loadData(is, myUseConstrEdges);
1001  loadData(is, myConstrEdges);
1002  loadData(is, myUseConstrPolys);
1003  loadData(is, myConstrPolys);
1004  loadData(is, myIgnorePolyBridges);
1005  loadData(is, myUseSilhouettePolys);
1006  loadData(is, mySilhouettePolys);
1007  loadData(is, myAllowConstrSplit);
1008  loadData(is, myUseExactConstruction);
1009  loadData(is, myIgnoreNonConstrPts);
1010  loadData(is, myRemoveFromConvexHull);
1011  loadData(is, myRemoveFromConstrPolys);
1012  loadData(is, myRemoveOutsideSilhouette);
1013  loadData(is, myRefine);
1014  loadData(is, myAllowRefineConstrSplits);
1015  loadData(is, myEncroachAngle);
1016  loadData(is, myMinAngle);
1017  loadData(is, myTriangleSize);
1018  loadData(is, myMaxArea);
1019  loadData(is, myTargetEdgeLength);
1020  loadData(is, myMinEdgeLength);
1021  loadData(is, myMaxNewPts);
1022  loadData(is, myNumLloydSteps);
1023  loadData(is, myAllowMovingInteriorInputPts);
1024  loadData(is, myRestorePos);
1025  loadData(is, myKeepPrims);
1026  loadData(is, myUpdateNormals);
1027  loadData(is, myRemoveUnusedPts);
1028  loadData(is, myRemoveDuplicatePts);
1029  loadData(is, myUseConstrSplitPtsGrp);
1030  loadData(is, myConstrSplitPtsGrp);
1031  loadData(is, myUseConstrdEdges);
1032  loadData(is, myConstrdEdges);
1033  loadData(is, myRandomSeed);
1034 
1035  return true;
1036  }
1037 
1038  const UT_StringHolder & getPoints() const { return myPoints; }
1039  void setPoints(const UT_StringHolder & val) { myPoints = val; }
1040  UT_StringHolder opPoints(const SOP_NodeVerb::CookParms &cookparms) const
1041  {
1042  SOP_Node *thissop = cookparms.getNode();
1043  if (!thissop) return getPoints();
1044  UT_StringHolder result;
1045  OP_Utils::evalOpParm(result, thissop, "points", cookparms.getCookTime(), 0);
1046  return result;
1047  }
1048  PlanePosSrc getPlanePosSrc() const { return PlanePosSrc(myPlanePosSrc); }
1049  void setPlanePosSrc(PlanePosSrc val) { myPlanePosSrc = int64(val); }
1050  PlanePosSrc opPlanePosSrc(const SOP_NodeVerb::CookParms &cookparms) const
1051  {
1052  SOP_Node *thissop = cookparms.getNode();
1053  if (!thissop) return getPlanePosSrc();
1054  int64 result;
1055  OP_Utils::evalOpParm(result, thissop, "planepossrc", cookparms.getCookTime(), 0);
1056  return PlanePosSrc(result);
1057  }
1058  UT_Vector3D getOrigin() const { return myOrigin; }
1059  void setOrigin(UT_Vector3D val) { myOrigin = val; }
1060  UT_Vector3D opOrigin(const SOP_NodeVerb::CookParms &cookparms) const
1061  {
1062  SOP_Node *thissop = cookparms.getNode();
1063  if (!thissop) return getOrigin();
1064  UT_Vector3D result;
1065  OP_Utils::evalOpParm(result, thissop, "origin", cookparms.getCookTime(), 0);
1066  return result;
1067  }
1068  fpreal64 getDist() const { return myDist; }
1069  void setDist(fpreal64 val) { myDist = val; }
1070  fpreal64 opDist(const SOP_NodeVerb::CookParms &cookparms) const
1071  {
1072  SOP_Node *thissop = cookparms.getNode();
1073  if (!thissop) return getDist();
1074  fpreal64 result;
1075  OP_Utils::evalOpParm(result, thissop, "dist", cookparms.getCookTime(), 0);
1076  return result;
1077  }
1078  UT_Vector3D getDir() const { return myDir; }
1079  void setDir(UT_Vector3D val) { myDir = val; }
1080  UT_Vector3D opDir(const SOP_NodeVerb::CookParms &cookparms) const
1081  {
1082  SOP_Node *thissop = cookparms.getNode();
1083  if (!thissop) return getDir();
1084  UT_Vector3D result;
1085  OP_Utils::evalOpParm(result, thissop, "dir", cookparms.getCookTime(), 0);
1086  return result;
1087  }
1088  const UT_StringHolder & getPos2AttribName() const { return myPos2AttribName; }
1089  void setPos2AttribName(const UT_StringHolder & val) { myPos2AttribName = val; }
1090  UT_StringHolder opPos2AttribName(const SOP_NodeVerb::CookParms &cookparms) const
1091  {
1092  SOP_Node *thissop = cookparms.getNode();
1093  if (!thissop) return getPos2AttribName();
1094  UT_StringHolder result;
1095  OP_Utils::evalOpParm(result, thissop, "pos2attrib", cookparms.getCookTime(), 0);
1096  return result;
1097  }
1098  bool getUseConstrEdges() const { return myUseConstrEdges; }
1099  void setUseConstrEdges(bool val) { myUseConstrEdges = val; }
1100  bool opUseConstrEdges(const SOP_NodeVerb::CookParms &cookparms) const
1101  {
1102  SOP_Node *thissop = cookparms.getNode();
1103  if (!thissop) return getUseConstrEdges();
1104  bool result;
1105  OP_Utils::evalOpParm(result, thissop, "useconstredges", cookparms.getCookTime(), 0);
1106  return result;
1107  }
1108  const UT_StringHolder & getConstrEdges() const { return myConstrEdges; }
1109  void setConstrEdges(const UT_StringHolder & val) { myConstrEdges = val; }
1110  UT_StringHolder opConstrEdges(const SOP_NodeVerb::CookParms &cookparms) const
1111  {
1112  SOP_Node *thissop = cookparms.getNode();
1113  if (!thissop) return getConstrEdges();
1114  UT_StringHolder result;
1115  OP_Utils::evalOpParm(result, thissop, "constredges", cookparms.getCookTime(), 0);
1116  return result;
1117  }
1118  bool getUseConstrPolys() const { return myUseConstrPolys; }
1119  void setUseConstrPolys(bool val) { myUseConstrPolys = val; }
1120  bool opUseConstrPolys(const SOP_NodeVerb::CookParms &cookparms) const
1121  {
1122  SOP_Node *thissop = cookparms.getNode();
1123  if (!thissop) return getUseConstrPolys();
1124  bool result;
1125  OP_Utils::evalOpParm(result, thissop, "useconstrpolys", cookparms.getCookTime(), 0);
1126  return result;
1127  }
1128  const UT_StringHolder & getConstrPolys() const { return myConstrPolys; }
1129  void setConstrPolys(const UT_StringHolder & val) { myConstrPolys = val; }
1130  UT_StringHolder opConstrPolys(const SOP_NodeVerb::CookParms &cookparms) const
1131  {
1132  SOP_Node *thissop = cookparms.getNode();
1133  if (!thissop) return getConstrPolys();
1134  UT_StringHolder result;
1135  OP_Utils::evalOpParm(result, thissop, "constrpolys", cookparms.getCookTime(), 0);
1136  return result;
1137  }
1138  bool getIgnorePolyBridges() const { return myIgnorePolyBridges; }
1139  void setIgnorePolyBridges(bool val) { myIgnorePolyBridges = val; }
1140  bool opIgnorePolyBridges(const SOP_NodeVerb::CookParms &cookparms) const
1141  {
1142  SOP_Node *thissop = cookparms.getNode();
1143  if (!thissop) return getIgnorePolyBridges();
1144  bool result;
1145  OP_Utils::evalOpParm(result, thissop, "ignorepolybridges", cookparms.getCookTime(), 0);
1146  return result;
1147  }
1148  bool getUseSilhouettePolys() const { return myUseSilhouettePolys; }
1149  void setUseSilhouettePolys(bool val) { myUseSilhouettePolys = val; }
1150  bool opUseSilhouettePolys(const SOP_NodeVerb::CookParms &cookparms) const
1151  {
1152  SOP_Node *thissop = cookparms.getNode();
1153  if (!thissop) return getUseSilhouettePolys();
1154  bool result;
1155  OP_Utils::evalOpParm(result, thissop, "usesilhouettepolys", cookparms.getCookTime(), 0);
1156  return result;
1157  }
1158  const UT_StringHolder & getSilhouettePolys() const { return mySilhouettePolys; }
1159  void setSilhouettePolys(const UT_StringHolder & val) { mySilhouettePolys = val; }
1160  UT_StringHolder opSilhouettePolys(const SOP_NodeVerb::CookParms &cookparms) const
1161  {
1162  SOP_Node *thissop = cookparms.getNode();
1163  if (!thissop) return getSilhouettePolys();
1164  UT_StringHolder result;
1165  OP_Utils::evalOpParm(result, thissop, "silhouettepolys", cookparms.getCookTime(), 0);
1166  return result;
1167  }
1168  bool getAllowConstrSplit() const { return myAllowConstrSplit; }
1169  void setAllowConstrSplit(bool val) { myAllowConstrSplit = val; }
1170  bool opAllowConstrSplit(const SOP_NodeVerb::CookParms &cookparms) const
1171  {
1172  SOP_Node *thissop = cookparms.getNode();
1173  if (!thissop) return getAllowConstrSplit();
1174  bool result;
1175  OP_Utils::evalOpParm(result, thissop, "allowconstrsplit", cookparms.getCookTime(), 0);
1176  return result;
1177  }
1178  bool getUseExactConstruction() const { return myUseExactConstruction; }
1179  void setUseExactConstruction(bool val) { myUseExactConstruction = val; }
1180  bool opUseExactConstruction(const SOP_NodeVerb::CookParms &cookparms) const
1181  {
1182  SOP_Node *thissop = cookparms.getNode();
1183  if (!thissop) return getUseExactConstruction();
1184  bool result;
1185  OP_Utils::evalOpParm(result, thissop, "useexactconstruction", cookparms.getCookTime(), 0);
1186  return result;
1187  }
1188  bool getIgnoreNonConstrPts() const { return myIgnoreNonConstrPts; }
1189  void setIgnoreNonConstrPts(bool val) { myIgnoreNonConstrPts = val; }
1190  bool opIgnoreNonConstrPts(const SOP_NodeVerb::CookParms &cookparms) const
1191  {
1192  SOP_Node *thissop = cookparms.getNode();
1193  if (!thissop) return getIgnoreNonConstrPts();
1194  bool result;
1195  OP_Utils::evalOpParm(result, thissop, "ignorenonconstrpts", cookparms.getCookTime(), 0);
1196  return result;
1197  }
1198  bool getRemoveFromConvexHull() const { return myRemoveFromConvexHull; }
1199  void setRemoveFromConvexHull(bool val) { myRemoveFromConvexHull = val; }
1200  bool opRemoveFromConvexHull(const SOP_NodeVerb::CookParms &cookparms) const
1201  {
1202  SOP_Node *thissop = cookparms.getNode();
1203  if (!thissop) return getRemoveFromConvexHull();
1204  bool result;
1205  OP_Utils::evalOpParm(result, thissop, "removefromconvexhull", cookparms.getCookTime(), 0);
1206  return result;
1207  }
1208  bool getRemoveFromConstrPolys() const { return myRemoveFromConstrPolys; }
1209  void setRemoveFromConstrPolys(bool val) { myRemoveFromConstrPolys = val; }
1210  bool opRemoveFromConstrPolys(const SOP_NodeVerb::CookParms &cookparms) const
1211  {
1212  SOP_Node *thissop = cookparms.getNode();
1213  if (!thissop) return getRemoveFromConstrPolys();
1214  bool result;
1215  OP_Utils::evalOpParm(result, thissop, "removefromconstrpolys", cookparms.getCookTime(), 0);
1216  return result;
1217  }
1218  bool getRemoveOutsideSilhouette() const { return myRemoveOutsideSilhouette; }
1219  void setRemoveOutsideSilhouette(bool val) { myRemoveOutsideSilhouette = val; }
1220  bool opRemoveOutsideSilhouette(const SOP_NodeVerb::CookParms &cookparms) const
1221  {
1222  SOP_Node *thissop = cookparms.getNode();
1223  if (!thissop) return getRemoveOutsideSilhouette();
1224  bool result;
1225  OP_Utils::evalOpParm(result, thissop, "removeoutsidesilhouette", cookparms.getCookTime(), 0);
1226  return result;
1227  }
1228  bool getRefine() const { return myRefine; }
1229  void setRefine(bool val) { myRefine = val; }
1230  bool opRefine(const SOP_NodeVerb::CookParms &cookparms) const
1231  {
1232  SOP_Node *thissop = cookparms.getNode();
1233  if (!thissop) return getRefine();
1234  bool result;
1235  OP_Utils::evalOpParm(result, thissop, "refine", cookparms.getCookTime(), 0);
1236  return result;
1237  }
1238  bool getAllowRefineConstrSplits() const { return myAllowRefineConstrSplits; }
1239  void setAllowRefineConstrSplits(bool val) { myAllowRefineConstrSplits = val; }
1240  bool opAllowRefineConstrSplits(const SOP_NodeVerb::CookParms &cookparms) const
1241  {
1242  SOP_Node *thissop = cookparms.getNode();
1243  if (!thissop) return getAllowRefineConstrSplits();
1244  bool result;
1245  OP_Utils::evalOpParm(result, thissop, "allowrefineonstrsplit", cookparms.getCookTime(), 0);
1246  return result;
1247  }
1248  fpreal64 getEncroachAngle() const { return myEncroachAngle; }
1249  void setEncroachAngle(fpreal64 val) { myEncroachAngle = val; }
1250  fpreal64 opEncroachAngle(const SOP_NodeVerb::CookParms &cookparms) const
1251  {
1252  SOP_Node *thissop = cookparms.getNode();
1253  if (!thissop) return getEncroachAngle();
1254  fpreal64 result;
1255  OP_Utils::evalOpParm(result, thissop, "encroachangle", cookparms.getCookTime(), 0);
1256  return result;
1257  }
1258  fpreal64 getMinAngle() const { return myMinAngle; }
1259  void setMinAngle(fpreal64 val) { myMinAngle = val; }
1260  fpreal64 opMinAngle(const SOP_NodeVerb::CookParms &cookparms) const
1261  {
1262  SOP_Node *thissop = cookparms.getNode();
1263  if (!thissop) return getMinAngle();
1264  fpreal64 result;
1265  OP_Utils::evalOpParm(result, thissop, "minangle", cookparms.getCookTime(), 0);
1266  return result;
1267  }
1268  TriangleSize getTriangleSize() const { return TriangleSize(myTriangleSize); }
1269  void setTriangleSize(TriangleSize val) { myTriangleSize = int64(val); }
1270  TriangleSize opTriangleSize(const SOP_NodeVerb::CookParms &cookparms) const
1271  {
1272  SOP_Node *thissop = cookparms.getNode();
1273  if (!thissop) return getTriangleSize();
1274  int64 result;
1275  OP_Utils::evalOpParm(result, thissop, "trianglesize", cookparms.getCookTime(), 0);
1276  return TriangleSize(result);
1277  }
1278  fpreal64 getMaxArea() const { return myMaxArea; }
1279  void setMaxArea(fpreal64 val) { myMaxArea = val; }
1280  fpreal64 opMaxArea(const SOP_NodeVerb::CookParms &cookparms) const
1281  {
1282  SOP_Node *thissop = cookparms.getNode();
1283  if (!thissop) return getMaxArea();
1284  fpreal64 result;
1285  OP_Utils::evalOpParm(result, thissop, "maxarea", cookparms.getCookTime(), 0);
1286  return result;
1287  }
1288  fpreal64 getTargetEdgeLength() const { return myTargetEdgeLength; }
1289  void setTargetEdgeLength(fpreal64 val) { myTargetEdgeLength = val; }
1290  fpreal64 opTargetEdgeLength(const SOP_NodeVerb::CookParms &cookparms) const
1291  {
1292  SOP_Node *thissop = cookparms.getNode();
1293  if (!thissop) return getTargetEdgeLength();
1294  fpreal64 result;
1295  OP_Utils::evalOpParm(result, thissop, "targetedgelength", cookparms.getCookTime(), 0);
1296  return result;
1297  }
1298  fpreal64 getMinEdgeLength() const { return myMinEdgeLength; }
1299  void setMinEdgeLength(fpreal64 val) { myMinEdgeLength = val; }
1300  fpreal64 opMinEdgeLength(const SOP_NodeVerb::CookParms &cookparms) const
1301  {
1302  SOP_Node *thissop = cookparms.getNode();
1303  if (!thissop) return getMinEdgeLength();
1304  fpreal64 result;
1305  OP_Utils::evalOpParm(result, thissop, "minedgelength", cookparms.getCookTime(), 0);
1306  return result;
1307  }
1308  int64 getMaxNewPts() const { return myMaxNewPts; }
1309  void setMaxNewPts(int64 val) { myMaxNewPts = val; }
1310  int64 opMaxNewPts(const SOP_NodeVerb::CookParms &cookparms) const
1311  {
1312  SOP_Node *thissop = cookparms.getNode();
1313  if (!thissop) return getMaxNewPts();
1314  int64 result;
1315  OP_Utils::evalOpParm(result, thissop, "maxnewpts", cookparms.getCookTime(), 0);
1316  return result;
1317  }
1318  int64 getNumLloydSteps() const { return myNumLloydSteps; }
1319  void setNumLloydSteps(int64 val) { myNumLloydSteps = val; }
1320  int64 opNumLloydSteps(const SOP_NodeVerb::CookParms &cookparms) const
1321  {
1322  SOP_Node *thissop = cookparms.getNode();
1323  if (!thissop) return getNumLloydSteps();
1324  int64 result;
1325  OP_Utils::evalOpParm(result, thissop, "lloydsteps", cookparms.getCookTime(), 0);
1326  return result;
1327  }
1328  bool getAllowMovingInteriorInputPts() const { return myAllowMovingInteriorInputPts; }
1329  void setAllowMovingInteriorInputPts(bool val) { myAllowMovingInteriorInputPts = val; }
1330  bool opAllowMovingInteriorInputPts(const SOP_NodeVerb::CookParms &cookparms) const
1331  {
1332  SOP_Node *thissop = cookparms.getNode();
1333  if (!thissop) return getAllowMovingInteriorInputPts();
1334  bool result;
1335  OP_Utils::evalOpParm(result, thissop, "allowmovinginteriorpts", cookparms.getCookTime(), 0);
1336  return result;
1337  }
1338  bool getRestorePos() const { return myRestorePos; }
1339  void setRestorePos(bool val) { myRestorePos = val; }
1340  bool opRestorePos(const SOP_NodeVerb::CookParms &cookparms) const
1341  {
1342  SOP_Node *thissop = cookparms.getNode();
1343  if (!thissop) return getRestorePos();
1344  bool result;
1345  OP_Utils::evalOpParm(result, thissop, "restorepos", cookparms.getCookTime(), 0);
1346  return result;
1347  }
1348  bool getKeepPrims() const { return myKeepPrims; }
1349  void setKeepPrims(bool val) { myKeepPrims = val; }
1350  bool opKeepPrims(const SOP_NodeVerb::CookParms &cookparms) const
1351  {
1352  SOP_Node *thissop = cookparms.getNode();
1353  if (!thissop) return getKeepPrims();
1354  bool result;
1355  OP_Utils::evalOpParm(result, thissop, "keepprims", cookparms.getCookTime(), 0);
1356  return result;
1357  }
1358  bool getUpdateNormals() const { return myUpdateNormals; }
1359  void setUpdateNormals(bool val) { myUpdateNormals = val; }
1360  bool opUpdateNormals(const SOP_NodeVerb::CookParms &cookparms) const
1361  {
1362  SOP_Node *thissop = cookparms.getNode();
1363  if (!thissop) return getUpdateNormals();
1364  bool result;
1365  OP_Utils::evalOpParm(result, thissop, "updatenmls", cookparms.getCookTime(), 0);
1366  return result;
1367  }
1368  bool getRemoveUnusedPts() const { return myRemoveUnusedPts; }
1369  void setRemoveUnusedPts(bool val) { myRemoveUnusedPts = val; }
1370  bool opRemoveUnusedPts(const SOP_NodeVerb::CookParms &cookparms) const
1371  {
1372  SOP_Node *thissop = cookparms.getNode();
1373  if (!thissop) return getRemoveUnusedPts();
1374  bool result;
1375  OP_Utils::evalOpParm(result, thissop, "removeunusedpoints", cookparms.getCookTime(), 0);
1376  return result;
1377  }
1378  bool getRemoveDuplicatePts() const { return myRemoveDuplicatePts; }
1379  void setRemoveDuplicatePts(bool val) { myRemoveDuplicatePts = val; }
1380  bool opRemoveDuplicatePts(const SOP_NodeVerb::CookParms &cookparms) const
1381  {
1382  SOP_Node *thissop = cookparms.getNode();
1383  if (!thissop) return getRemoveDuplicatePts();
1384  bool result;
1385  OP_Utils::evalOpParm(result, thissop, "removeduplicatepoints", cookparms.getCookTime(), 0);
1386  return result;
1387  }
1388  bool getUseConstrSplitPtsGrp() const { return myUseConstrSplitPtsGrp; }
1389  void setUseConstrSplitPtsGrp(bool val) { myUseConstrSplitPtsGrp = val; }
1390  bool opUseConstrSplitPtsGrp(const SOP_NodeVerb::CookParms &cookparms) const
1391  {
1392  SOP_Node *thissop = cookparms.getNode();
1393  if (!thissop) return getUseConstrSplitPtsGrp();
1394  bool result;
1395  OP_Utils::evalOpParm(result, thissop, "usecontrsplitptgrp", cookparms.getCookTime(), 0);
1396  return result;
1397  }
1398  const UT_StringHolder & getConstrSplitPtsGrp() const { return myConstrSplitPtsGrp; }
1399  void setConstrSplitPtsGrp(const UT_StringHolder & val) { myConstrSplitPtsGrp = val; }
1400  UT_StringHolder opConstrSplitPtsGrp(const SOP_NodeVerb::CookParms &cookparms) const
1401  {
1402  SOP_Node *thissop = cookparms.getNode();
1403  if (!thissop) return getConstrSplitPtsGrp();
1404  UT_StringHolder result;
1405  OP_Utils::evalOpParm(result, thissop, "constrsplitptgrp", cookparms.getCookTime(), 0);
1406  return result;
1407  }
1408  bool getUseConstrdEdges() const { return myUseConstrdEdges; }
1409  void setUseConstrdEdges(bool val) { myUseConstrdEdges = val; }
1410  bool opUseConstrdEdges(const SOP_NodeVerb::CookParms &cookparms) const
1411  {
1412  SOP_Node *thissop = cookparms.getNode();
1413  if (!thissop) return getUseConstrdEdges();
1414  bool result;
1415  OP_Utils::evalOpParm(result, thissop, "useconstrdedges", cookparms.getCookTime(), 0);
1416  return result;
1417  }
1418  const UT_StringHolder & getConstrdEdges() const { return myConstrdEdges; }
1419  void setConstrdEdges(const UT_StringHolder & val) { myConstrdEdges = val; }
1420  UT_StringHolder opConstrdEdges(const SOP_NodeVerb::CookParms &cookparms) const
1421  {
1422  SOP_Node *thissop = cookparms.getNode();
1423  if (!thissop) return getConstrdEdges();
1424  UT_StringHolder result;
1425  OP_Utils::evalOpParm(result, thissop, "constrdedges", cookparms.getCookTime(), 0);
1426  return result;
1427  }
1428  int64 getRandomSeed() const { return myRandomSeed; }
1429  void setRandomSeed(int64 val) { myRandomSeed = val; }
1430  int64 opRandomSeed(const SOP_NodeVerb::CookParms &cookparms) const
1431  {
1432  SOP_Node *thissop = cookparms.getNode();
1433  if (!thissop) return getRandomSeed();
1434  int64 result;
1435  OP_Utils::evalOpParm(result, thissop, "randseed", cookparms.getCookTime(), 0);
1436  return result;
1437  }
1438 
1439 private:
1440  UT_StringHolder myPoints;
1441  int64 myPlanePosSrc;
1442  UT_Vector3D myOrigin;
1443  fpreal64 myDist;
1444  UT_Vector3D myDir;
1445  UT_StringHolder myPos2AttribName;
1446  bool myUseConstrEdges;
1447  UT_StringHolder myConstrEdges;
1448  bool myUseConstrPolys;
1449  UT_StringHolder myConstrPolys;
1450  bool myIgnorePolyBridges;
1451  bool myUseSilhouettePolys;
1452  UT_StringHolder mySilhouettePolys;
1453  bool myAllowConstrSplit;
1454  bool myUseExactConstruction;
1455  bool myIgnoreNonConstrPts;
1456  bool myRemoveFromConvexHull;
1457  bool myRemoveFromConstrPolys;
1458  bool myRemoveOutsideSilhouette;
1459  bool myRefine;
1460  bool myAllowRefineConstrSplits;
1461  fpreal64 myEncroachAngle;
1462  fpreal64 myMinAngle;
1463  int64 myTriangleSize;
1464  fpreal64 myMaxArea;
1465  fpreal64 myTargetEdgeLength;
1466  fpreal64 myMinEdgeLength;
1467  int64 myMaxNewPts;
1468  int64 myNumLloydSteps;
1469  bool myAllowMovingInteriorInputPts;
1470  bool myRestorePos;
1471  bool myKeepPrims;
1472  bool myUpdateNormals;
1473  bool myRemoveUnusedPts;
1474  bool myRemoveDuplicatePts;
1475  bool myUseConstrSplitPtsGrp;
1476  UT_StringHolder myConstrSplitPtsGrp;
1477  bool myUseConstrdEdges;
1478  UT_StringHolder myConstrdEdges;
1479  int64 myRandomSeed;
1480 
1481 };
SOP_Triangulate2D_3_0Enums::TriangleSize
TriangleSize
Definition: SOP_Triangulate2D-3.0.proto.h:44
SOP_Triangulate2D_3_0Parms::opConstrPolys
UT_StringHolder opConstrPolys(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1130
SOP_Triangulate2D_3_0Parms::opTriangleSize
TriangleSize opTriangleSize(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1270
SOP_Triangulate2D_3_0Parms::getRandomSeed
int64 getRandomSeed() const
Definition: SOP_Triangulate2D-3.0.proto.h:1428
SOP_Triangulate2D_3_0Parms::load
bool load(UT_IStream &is)
Definition: SOP_Triangulate2D-3.0.proto.h:985
SOP_Triangulate2D_3_0Parms::opMaxArea
fpreal64 opMaxArea(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1280
SOP_Triangulate2D_3_0Parms::opMinEdgeLength
fpreal64 opMinEdgeLength(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1300
UT_Matrix2T< fpreal64 >
UT_Matrix3T< fpreal64 >
SOP_Triangulate2D_3_0Parms::opPlanePosSrc
PlanePosSrc opPlanePosSrc(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1050
SOP_Triangulate2D_3_0Parms::setConstrPolys
void setConstrPolys(const UT_StringHolder &val)
Definition: SOP_Triangulate2D-3.0.proto.h:1129
SOP_Triangulate2D_3_0Parms::buildFromOp
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
Definition: SOP_Triangulate2D-3.0.proto.h:177
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_Vector3D v)
Definition: SOP_Triangulate2D-3.0.proto.h:903
SOP_Triangulate2D_3_0Parms::getIgnorePolyBridges
bool getIgnorePolyBridges() const
Definition: SOP_Triangulate2D-3.0.proto.h:1138
SOP_Triangulate2D_3_0Parms::setUpdateNormals
void setUpdateNormals(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1359
UT_Matrix4T< fpreal64 >
UT_SharedPtr.h
SOP_Triangulate2D_3_0Parms::getMinAngle
fpreal64 getMinAngle() const
Definition: SOP_Triangulate2D-3.0.proto.h:1258
SOP_Triangulate2D_3_0Parms::opUseConstrEdges
bool opUseConstrEdges(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1100
SOP_GraphProxy.h
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:620
int32
int int32
Definition: SYS_Types.h:39
SOP_NodeVerb::CookParms::getNode
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:347
SOP_Triangulate2D_3_0Parms::loadFromOpSubclass
void loadFromOpSubclass(const LoadParms &loadparms) override
Definition: SOP_Triangulate2D-3.0.proto.h:303
SOP_Triangulate2D_3_0Parms::opRandomSeed
int64 opRandomSeed(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1430
SOP_Triangulate2D_3_0Parms
Definition: SOP_Triangulate2D-3.0.proto.h:66
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:472
SOP_Triangulate2D_3_0Parms::getPlanePosSrc
PlanePosSrc getPlanePosSrc() const
Definition: SOP_Triangulate2D-3.0.proto.h:1048
SOP_Triangulate2D_3_0Parms::opConstrdEdges
UT_StringHolder opConstrdEdges(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1420
UT_WorkBuffer
Definition: UT_WorkBuffer.h:74
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:622
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Matrix2D &v)
Definition: SOP_Triangulate2D-3.0.proto.h:848
SOP_Triangulate2D_3_0Parms::getRefine
bool getRefine() const
Definition: SOP_Triangulate2D-3.0.proto.h:1228
SOP_Triangulate2D_3_0Parms::getUseSilhouettePolys
bool getUseSilhouettePolys() const
Definition: SOP_Triangulate2D-3.0.proto.h:1148
SOP_Triangulate2D_3_0Parms::getNestParmName
const char * getNestParmName(TempIndex fieldnum) const override
Definition: SOP_Triangulate2D-3.0.proto.h:651
OP_GraphProxy
Definition: OP_GraphProxy.h:32
SOP_Triangulate2D_3_0Parms::opKeepPrims
bool opKeepPrims(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1350
UT_IStream::bread
exint bread(int32 *buffer, exint asize=1)
data
GLboolean * data
Definition: glcorearb.h:131
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Vector4I &v)
Definition: SOP_Triangulate2D-3.0.proto.h:859
SOP_Triangulate2D_3_0Parms::copyFrom
void copyFrom(const OP_NodeParms *src) override
Definition: SOP_Triangulate2D-3.0.proto.h:309
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_Triangulate2D_3_0Parms::opRemoveFromConvexHull
bool opRemoveFromConvexHull(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1200
v
const GLdouble * v
Definition: glcorearb.h:837
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
Definition: SOP_Triangulate2D-3.0.proto.h:917
OP_Context::getTime
fpreal getTime() const
Definition: OP_Context.h:62
SOP_Triangulate2D_3_0Parms::opPos2AttribName
UT_StringHolder opPos2AttribName(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1090
SOP_Triangulate2D_3_0Parms::opMinAngle
fpreal64 opMinAngle(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1260
SOP_Triangulate2D_3_0Parms::getRestorePos
bool getRestorePos() const
Definition: SOP_Triangulate2D-3.0.proto.h:1338
SOP_Triangulate2D_3_0Parms::setMaxNewPts
void setMaxNewPts(int64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1309
SOP_Triangulate2D_3_0Parms::setUseSilhouettePolys
void setUseSilhouettePolys(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1149
SOP_Triangulate2D_3_0Parms::setUseConstrPolys
void setUseConstrPolys(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1119
SOP_Triangulate2D_3_0Parms::operator!=
bool operator!=(const SOP_Triangulate2D_3_0Parms &src) const
Definition: SOP_Triangulate2D-3.0.proto.h:168
SOP_Triangulate2D_3_0Parms::getUpdateNormals
bool getUpdateNormals() const
Definition: SOP_Triangulate2D-3.0.proto.h:1358
SOP_Triangulate2D_3_0Parms::getDir
UT_Vector3D getDir() const
Definition: SOP_Triangulate2D-3.0.proto.h:1078
UT_IStream
Definition: UT_IStream.h:56
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_Matrix4D v)
Definition: SOP_Triangulate2D-3.0.proto.h:913
SOP_Triangulate2D_3_0Enums::TriangleSize::CAPMAXAREA
SOP_Triangulate2D_3_0Parms::getConstrEdges
const UT_StringHolder & getConstrEdges() const
Definition: SOP_Triangulate2D-3.0.proto.h:1108
OP_NodeParms::LoadParms::context
const OP_Context & context() const
Definition: OP_NodeParms.h:97
SOP_Triangulate2D_3_0Parms::opAllowConstrSplit
bool opAllowConstrSplit(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1170
SOP_Triangulate2D_3_0Parms::getTargetEdgeLength
fpreal64 getTargetEdgeLength() const
Definition: SOP_Triangulate2D-3.0.proto.h:1288
UT_Vector3T::z
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector3.h:667
exint
int64 exint
Definition: SYS_Types.h:125
SOP_Triangulate2D_3_0Parms::setRemoveOutsideSilhouette
void setRemoveOutsideSilhouette(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1219
UT_IStream.h
UT_WorkBuffer::buffer
SYS_FORCE_INLINE const char * buffer() const
Definition: UT_WorkBuffer.h:169
s
GLdouble s
Definition: glad.h:3009
SOP_Triangulate2D_3_0Parms::opUpdateNormals
bool opUpdateNormals(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1360
SOP_Triangulate2D_3_0Parms::setPoints
void setPoints(const UT_StringHolder &val)
Definition: SOP_Triangulate2D-3.0.proto.h:1039
SOP_Triangulate2D_3_0Enums::PlanePosSrc::USEATTRIB
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_StringHolder &v)
Definition: SOP_Triangulate2D-3.0.proto.h:862
UT_OStringStream
An output stream object that owns its own string buffer storage.
Definition: UT_StringStream.h:159
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_Matrix3D v)
Definition: SOP_Triangulate2D-3.0.proto.h:911
SOP_Triangulate2D_3_0Parms::setTargetEdgeLength
void setTargetEdgeLength(fpreal64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1289
SOP_Triangulate2D_3_0Parms::getNestNumParms
exint getNestNumParms(TempIndex idx) const override
Definition: SOP_Triangulate2D-3.0.proto.h:639
SOP_Triangulate2D_3_0Parms::getNestParmType
ParmType getNestParmType(TempIndex fieldnum) const override
Definition: SOP_Triangulate2D-3.0.proto.h:742
result
**But if you need a result
Definition: thread.h:613
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:616
SOP_Triangulate2D_3_0Parms::setRemoveFromConstrPolys
void setRemoveFromConstrPolys(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1209
SOP_Triangulate2D_3_0Parms::doGetParmValue
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
Definition: SOP_Triangulate2D-3.0.proto.h:316
SOP_Triangulate2D_3_0Parms::getIgnoreNonConstrPts
bool getIgnoreNonConstrPts() const
Definition: SOP_Triangulate2D-3.0.proto.h:1188
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:634
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:474
SOP_Triangulate2D_3_0Parms::save
void save(std::ostream &os) const
Definition: SOP_Triangulate2D-3.0.proto.h:938
UT_Vector3T< fpreal64 >
UT_Vector4T< fpreal64 >
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, bool &v)
Definition: SOP_Triangulate2D-3.0.proto.h:836
UT_Vector2T< fpreal64 >
SOP_Triangulate2D_3_0Parms::setRefine
void setRefine(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1229
OP_NodeParms::LoadParms::nodeIdx
exint nodeIdx() const
Definition: OP_NodeParms.h:95
PRM_DataFactory::parseBinary
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
UT_StringWrap
Definition: UT_String.h:1375
UT_OStringStream::str
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
Definition: UT_StringStream.h:180
SOP_API.h
SOP_Triangulate2D_3_0Parms::opAllowRefineConstrSplits
bool opAllowRefineConstrSplits(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1240
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Matrix4D &v)
Definition: SOP_Triangulate2D-3.0.proto.h:852
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:618
SOP_Triangulate2D_3_0Parms::setRemoveFromConvexHull
void setRemoveFromConvexHull(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1199
SOP_Triangulate2D_3_0Parms::setEncroachAngle
void setEncroachAngle(fpreal64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1249
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:628
UT_Vector4T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector4.h:491
SOP_Triangulate2D_3_0Parms::opOrigin
UT_Vector3D opOrigin(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1060
SOP_Triangulate2D_3_0Parms::getRemoveFromConvexHull
bool getRemoveFromConvexHull() const
Definition: SOP_Triangulate2D-3.0.proto.h:1198
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:630
SOP_Triangulate2D_3_0Parms::opAllowMovingInteriorInputPts
bool opAllowMovingInteriorInputPts(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1330
SOP_Triangulate2D_3_0Parms::getUseConstrPolys
bool getUseConstrPolys() const
Definition: SOP_Triangulate2D-3.0.proto.h:1118
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:636
SOP_Triangulate2D_3_0Parms::getOrigin
UT_Vector3D getOrigin() const
Definition: SOP_Triangulate2D-3.0.proto.h:1058
SOP_Triangulate2D_3_0Parms::opEncroachAngle
fpreal64 opEncroachAngle(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1250
fpreal64
double fpreal64
Definition: SYS_Types.h:201
SOP_Triangulate2D_3_0Parms::setUseConstrEdges
void setUseConstrEdges(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1099
UT_Vector2T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector2.h:423
SOP_Triangulate2D_3_0Parms::opTargetEdgeLength
fpreal64 opTargetEdgeLength(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1290
SOP_Triangulate2D_3_0Parms::setRemoveDuplicatePts
void setRemoveDuplicatePts(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1379
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:999
SOP_Triangulate2D_3_0Parms::getRemoveUnusedPts
bool getRemoveUnusedPts() const
Definition: SOP_Triangulate2D-3.0.proto.h:1368
OP_NodeParms::TempIndex
Definition: OP_NodeParms.h:232
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_Matrix2D v)
Definition: SOP_Triangulate2D-3.0.proto.h:909
SYS_Types.h
SOP_Triangulate2D_3_0Parms::getNumLloydSteps
int64 getNumLloydSteps() const
Definition: SOP_Triangulate2D-3.0.proto.h:1318
SOP_Triangulate2D_3_0Parms::setUseConstrdEdges
void setUseConstrdEdges(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1409
SOP_Triangulate2D_3_0Parms::getPoints
const UT_StringHolder & getPoints() const
Definition: SOP_Triangulate2D-3.0.proto.h:1038
SOP_Triangulate2D_3_0Parms::getMaxNewPts
int64 getMaxNewPts() const
Definition: SOP_Triangulate2D-3.0.proto.h:1308
UT_NTStreamUtil.h
SOP_Triangulate2D_3_0Parms::setIgnoreNonConstrPts
void setIgnoreNonConstrPts(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1189
UT_StringRef::length
exint length() const
Definition: UT_StringHolder.h:749
SOP_Triangulate2D_3_0Parms::setKeepPrims
void setKeepPrims(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1349
SOP_Triangulate2D_3_0Parms::setMinAngle
void setMinAngle(fpreal64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1259
UT_ISTREAM_ASCII
Definition: UT_IStream.h:38
SOP_Triangulate2D_3_0Parms::setSilhouettePolys
void setSilhouettePolys(const UT_StringHolder &val)
Definition: SOP_Triangulate2D-3.0.proto.h:1159
SOP_Triangulate2D_3_0Parms::getMaxArea
fpreal64 getMaxArea() const
Definition: SOP_Triangulate2D-3.0.proto.h:1278
UT_StringRef::buffer
SYS_FORCE_INLINE const char * buffer() const
Definition: UT_StringHolder.h:570
UT_SharedPtr
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:36
SOP_Triangulate2D_3_0Parms::setMinEdgeLength
void setMinEdgeLength(fpreal64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1299
SOP_Triangulate2D_3_0Parms::opConstrSplitPtsGrp
UT_StringHolder opConstrSplitPtsGrp(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1400
UT_Vector4T::z
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector4.h:495
SOP_Triangulate2D_3_0Parms::opRemoveOutsideSilhouette
bool opRemoveOutsideSilhouette(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1220
SOP_Triangulate2D_3_0Parms::setPlanePosSrc
void setPlanePosSrc(PlanePosSrc val)
Definition: SOP_Triangulate2D-3.0.proto.h:1049
SOP_Triangulate2D_3_0Parms::getUseConstrdEdges
bool getUseConstrdEdges() const
Definition: SOP_Triangulate2D-3.0.proto.h:1408
SOP_Triangulate2D_3_0Enums::PlanePosSrc
PlanePosSrc
Definition: SOP_Triangulate2D-3.0.proto.h:25
SOP_Triangulate2D_3_0Enums::PlanePosSrc::FITPLANE
SOP_Triangulate2D_3_0Parms::setConstrdEdges
void setConstrdEdges(const UT_StringHolder &val)
Definition: SOP_Triangulate2D-3.0.proto.h:1419
SOP_Triangulate2D_3_0Parms::opRemoveFromConstrPolys
bool opRemoveFromConstrPolys(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1210
OP_NodeParms::LoadParms::graph
const OP_GraphProxy * graph() const
Definition: OP_NodeParms.h:94
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:632
SYS_FORCE_INLINE
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
PRM_Parm.h
SOP_Triangulate2D_3_0Enums::getToken
SYS_FORCE_INLINE UT_StringHolder getToken(PlanePosSrc enum_value)
Definition: SOP_Triangulate2D-3.0.proto.h:33
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Vector3D &v)
Definition: SOP_Triangulate2D-3.0.proto.h:842
OP_Utils.h
SOP_Triangulate2D_3_0Parms::setTriangleSize
void setTriangleSize(TriangleSize val)
Definition: SOP_Triangulate2D-3.0.proto.h:1269
OP_NodeParms::ParmType
ParmType
Definition: OP_NodeParms.h:158
UT_StringStream.h
SOP_Triangulate2D_3_0Parms::setDist
void setDist(fpreal64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1069
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Vector2D &v)
Definition: SOP_Triangulate2D-3.0.proto.h:840
int64
long long int64
Definition: SYS_Types.h:116
UT_VectorTypes.h
SOP_Triangulate2D_3_0Parms::getSilhouettePolys
const UT_StringHolder & getSilhouettePolys() const
Definition: SOP_Triangulate2D-3.0.proto.h:1158
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:470
SOP_Triangulate2D_3_0Parms::setAllowRefineConstrSplits
void setAllowRefineConstrSplits(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1239
SOP_Triangulate2D_3_0Parms::getRemoveOutsideSilhouette
bool getRemoveOutsideSilhouette() const
Definition: SOP_Triangulate2D-3.0.proto.h:1218
SOP_Triangulate2D_3_0Parms::opRefine
bool opRefine(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1230
SOP_Triangulate2D_3_0Parms::SOP_Triangulate2D_3_0Parms
SOP_Triangulate2D_3_0Parms()
Definition: SOP_Triangulate2D-3.0.proto.h:71
UT_Vector3D
UT_Vector3T< fpreal64 > UT_Vector3D
Definition: UT_VectorTypes.h:36
SOP_Triangulate2D_3_0Enums::TriangleSize::SETTARGETEDGELENGTH
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, int64 &v)
Definition: SOP_Triangulate2D-3.0.proto.h:834
SOP_Triangulate2D_3_0Parms::getPos2AttribName
const UT_StringHolder & getPos2AttribName() const
Definition: SOP_Triangulate2D-3.0.proto.h:1088
SOP_Triangulate2D_3_0Parms::getConstrdEdges
const UT_StringHolder & getConstrdEdges() const
Definition: SOP_Triangulate2D-3.0.proto.h:1418
SOP_Triangulate2D_3_0Parms::setConstrEdges
void setConstrEdges(const UT_StringHolder &val)
Definition: SOP_Triangulate2D-3.0.proto.h:1109
OP_GraphProxy::evalOpParm
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, PRM_DataItemHandle s)
Definition: SOP_Triangulate2D-3.0.proto.h:924
SOP_Triangulate2D_3_0Parms::getConstrSplitPtsGrp
const UT_StringHolder & getConstrSplitPtsGrp() const
Definition: SOP_Triangulate2D-3.0.proto.h:1398
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:624
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Vector3I &v)
Definition: SOP_Triangulate2D-3.0.proto.h:856
UT_EnvControl.h
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_Vector4D v)
Definition: SOP_Triangulate2D-3.0.proto.h:906
UT_String::saveBinary
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:296
SOP_Triangulate2D_3_0Parms::setMaxArea
void setMaxArea(fpreal64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1279
SOP_Triangulate2D_3_0Parms::operator==
bool operator==(const SOP_Triangulate2D_3_0Parms &src) const
Definition: SOP_Triangulate2D-3.0.proto.h:123
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:466
GT_Names::version
GT_API const UT_StringHolder version
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, int64 v)
Definition: SOP_Triangulate2D-3.0.proto.h:895
SOP_Triangulate2D_3_0Parms::getTriangleSize
TriangleSize getTriangleSize() const
Definition: SOP_Triangulate2D-3.0.proto.h:1268
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, fpreal64 &v)
Definition: SOP_Triangulate2D-3.0.proto.h:838
SOP_Triangulate2D_3_0Parms::setRemoveUnusedPts
void setRemoveUnusedPts(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1369
SOP_Triangulate2D_3_0Parms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
Definition: SOP_Triangulate2D-3.0.proto.h:626
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_Vector2D v)
Definition: SOP_Triangulate2D-3.0.proto.h:901
SOP_Triangulate2D_3_0Parms::opDir
UT_Vector3D opDir(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1080
SOP_Triangulate2D_3_0Parms::setRestorePos
void setRestorePos(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1339
SOP_Triangulate2D_3_0Parms::setOrigin
void setOrigin(UT_Vector3D val)
Definition: SOP_Triangulate2D-3.0.proto.h:1059
SOP_Triangulate2D_3_0Parms::opIgnorePolyBridges
bool opIgnorePolyBridges(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1140
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:478
SOP_Triangulate2D_3_0Parms::opUseExactConstruction
bool opUseExactConstruction(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1180
SOP_Triangulate2D_3_0Parms::opPoints
UT_StringHolder opPoints(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1040
SOP_Triangulate2D_3_0Parms::opUseConstrSplitPtsGrp
bool opUseConstrSplitPtsGrp(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1390
SOP_Triangulate2D_3_0Parms::opNumLloydSteps
int64 opNumLloydSteps(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1320
SOP_Triangulate2D_3_0Parms::opDist
fpreal64 opDist(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1070
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Matrix3D &v)
Definition: SOP_Triangulate2D-3.0.proto.h:850
SOP_Triangulate2D_3_0Parms::opRestorePos
bool opRestorePos(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1340
SOP_NodeVerb.h
UT_StringHolder.h
SOP_Triangulate2D_3_0Parms::setPos2AttribName
void setPos2AttribName(const UT_StringHolder &val)
Definition: SOP_Triangulate2D-3.0.proto.h:1089
SOP_Triangulate2D_3_0Enums::TriangleSize::UNRESTRICTED
SOP_Triangulate2D_3_0Parms::getMinEdgeLength
fpreal64 getMinEdgeLength() const
Definition: SOP_Triangulate2D-3.0.proto.h:1298
SOP_Triangulate2D_3_0Parms::opRemoveDuplicatePts
bool opRemoveDuplicatePts(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1380
SOP_Triangulate2D_3_0Parms::opUseConstrdEdges
bool opUseConstrdEdges(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1410
SOP_Triangulate2D_3_0Parms::opSilhouettePolys
UT_StringHolder opSilhouettePolys(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1160
fpreal
fpreal64 fpreal
Definition: SYS_Types.h:277
OP_NodeParms::LoadParms::depnode
DEP_MicroNode * depnode() const
Definition: OP_NodeParms.h:99
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:468
SOP_Triangulate2D_3_0Parms::getUseExactConstruction
bool getUseExactConstruction() const
Definition: SOP_Triangulate2D-3.0.proto.h:1178
nanovdb::operator=
LeafData & operator=(const LeafData &)=delete
UT_Ramp
Utility class for containing a color ramp.
Definition: UT_Ramp.h:92
SOP_Triangulate2D_3_0Parms::setIgnorePolyBridges
void setIgnorePolyBridges(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1139
SOP_Triangulate2D_3_0Parms::opRemoveUnusedPts
bool opRemoveUnusedPts(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1370
SOP_Triangulate2D_3_0Parms::getEncroachAngle
fpreal64 getEncroachAngle() const
Definition: SOP_Triangulate2D-3.0.proto.h:1248
SOP_Triangulate2D_3_0Parms::getRemoveFromConstrPolys
bool getRemoveFromConstrPolys() const
Definition: SOP_Triangulate2D-3.0.proto.h:1208
SOP_Triangulate2D_3_0Parms::opUseSilhouettePolys
bool opUseSilhouettePolys(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1150
UT_Vector4T::w
constexpr SYS_FORCE_INLINE T & w() noexcept
Definition: UT_Vector4.h:497
SOP_NodeParms
Definition: SOP_NodeVerb.h:58
SOP_Triangulate2D_3_0Parms::getUseConstrSplitPtsGrp
bool getUseConstrSplitPtsGrp() const
Definition: SOP_Triangulate2D-3.0.proto.h:1388
SOP_Triangulate2D_3_0Parms::getConstrPolys
const UT_StringHolder & getConstrPolys() const
Definition: SOP_Triangulate2D-3.0.proto.h:1128
val
GLuint GLfloat * val
Definition: glcorearb.h:1608
OP_NodeParms::LoadParms
Definition: OP_NodeParms.h:72
SOP_Triangulate2D_3_0Parms::getDist
fpreal64 getDist() const
Definition: SOP_Triangulate2D-3.0.proto.h:1068
UT_ISTREAM_BINARY
Definition: UT_IStream.h:39
SOP_API
#define SOP_API
Definition: SOP_API.h:10
SOP_Triangulate2D_3_0Parms::setNumLloydSteps
void setNumLloydSteps(int64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1319
OP_NodeParms
Definition: OP_NodeParms.h:66
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:458
SOP_NodeVerb::CookParms::getCookTime
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:361
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:476
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:462
SOP_NodeVerb::CookParms
Definition: SOP_NodeVerb.h:310
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
Definition: SOP_Triangulate2D-3.0.proto.h:864
UT_StringWrap::findChar
const char * findChar(int c) const
Definition: UT_String.h:1395
UT_ASSERT
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
value
Definition: core.h:1131
SOP_Triangulate2D_3_0Parms::getAllowMovingInteriorInputPts
bool getAllowMovingInteriorInputPts() const
Definition: SOP_Triangulate2D-3.0.proto.h:1328
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:460
SOP_Triangulate2D_3_0Parms::version
static int version()
Definition: SOP_Triangulate2D-3.0.proto.h:69
SOP_Triangulate2D_3_0Parms::getKeepPrims
bool getKeepPrims() const
Definition: SOP_Triangulate2D-3.0.proto.h:1348
r
GLboolean r
Definition: glcorearb.h:1222
SOP_Triangulate2D_3_0Parms::opIgnoreNonConstrPts
bool opIgnoreNonConstrPts(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1190
SOP_Triangulate2D_3_0Parms::setUseExactConstruction
void setUseExactConstruction(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1179
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Vector2I &v)
Definition: SOP_Triangulate2D-3.0.proto.h:854
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, fpreal64 v)
Definition: SOP_Triangulate2D-3.0.proto.h:899
DEP_MicroNode
Definition: DEP_MicroNode.h:60
SOP_Triangulate2D_3_0Parms::opUseConstrPolys
bool opUseConstrPolys(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1120
UT_Vector3T::y
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector3.h:665
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, UT_StringHolder s)
Definition: SOP_Triangulate2D-3.0.proto.h:915
SOP_Triangulate2D_3_0Parms::setRandomSeed
void setRandomSeed(int64 val)
Definition: SOP_Triangulate2D-3.0.proto.h:1429
SOP_Triangulate2D_3_0Parms::isParmColorRamp
bool isParmColorRamp(exint idx) const override
Definition: SOP_Triangulate2D-3.0.proto.h:449
OP_NodeParms::TempIndex::size
exint size() const
Definition: OP_NodeParms.h:250
type
type
Definition: core.h:1059
SOP_Triangulate2D_3_0Parms::saveData
static void saveData(std::ostream &os, bool v)
Definition: SOP_Triangulate2D-3.0.proto.h:897
SOP_Triangulate2D_3_0Parms::getAllowConstrSplit
bool getAllowConstrSplit() const
Definition: SOP_Triangulate2D-3.0.proto.h:1168
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, UT_Vector4D &v)
Definition: SOP_Triangulate2D-3.0.proto.h:845
SOP_Triangulate2D_3_0Parms::loadData
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
Definition: SOP_Triangulate2D-3.0.proto.h:875
SOP_Triangulate2D_3_0Parms::opConstrEdges
UT_StringHolder opConstrEdges(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1110
SOP_Triangulate2D_3_0Parms::opMaxNewPts
int64 opMaxNewPts(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_Triangulate2D-3.0.proto.h:1310
SOP_Triangulate2D_3_0Enums::PlanePosSrc::SETPROJPLANE
SOP_Triangulate2D_3_0Parms::setUseConstrSplitPtsGrp
void setUseConstrSplitPtsGrp(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1389
PRM_DataItemHandle
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:97
SOP_Triangulate2D_3_0Parms::setDir
void setDir(UT_Vector3D val)
Definition: SOP_Triangulate2D-3.0.proto.h:1079
SOP_Triangulate2D_3_0Parms::getAllowRefineConstrSplits
bool getAllowRefineConstrSplits() const
Definition: SOP_Triangulate2D-3.0.proto.h:1238
UT_Vector2T::y
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector2.h:425
UT_StringRef::isstring
SYS_FORCE_INLINE bool isstring() const
Definition: UT_StringHolder.h:607
SOP_Triangulate2D_3_0Parms::getRemoveDuplicatePts
bool getRemoveDuplicatePts() const
Definition: SOP_Triangulate2D-3.0.proto.h:1378
SOP_Triangulate2D_3_0Parms::setAllowConstrSplit
void setAllowConstrSplit(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1169
SOP_Triangulate2D_3_0Parms::setConstrSplitPtsGrp
void setConstrSplitPtsGrp(const UT_StringHolder &val)
Definition: SOP_Triangulate2D-3.0.proto.h:1399
SOP_Node
Definition: SOP_Node.h:108
UT_WorkBuffer::strncpy
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
Definition: UT_WorkBuffer.h:409
SOP_Triangulate2D_3_0Parms::setAllowMovingInteriorInputPts
void setAllowMovingInteriorInputPts(bool val)
Definition: SOP_Triangulate2D-3.0.proto.h:1329
SOP_Triangulate2D_3_0Parms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
Definition: SOP_Triangulate2D-3.0.proto.h:464
SOP_Triangulate2D_3_0Parms::doSetParmValue
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
Definition: SOP_Triangulate2D-3.0.proto.h:483
src
GLenum src
Definition: glcorearb.h:1793
UT_Vector3T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector3.h:663
SOP_Triangulate2D_3_0Parms::getUseConstrEdges
bool getUseConstrEdges() const
Definition: SOP_Triangulate2D-3.0.proto.h:1098
UT_Ramp.h