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