HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_Tetrahedralize-2.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_Tetrahedralize_2_0Enums
24 {
25  enum class Batch
26  {
27  ENTIRE = 0,
28  CONNECTED,
29  ATTRIB
30  };
31  enum class Mode
32  {
33  CONFORM = 0,
34  REFINE,
35  CONVEXHULL,
36  DETECT
37  };
38  enum class Output
39  {
40  POLYLINE = 0,
41  TETRAHEDRA,
42  POLYGONS,
43  POLYTET
44  };
45  enum class Failures
46  {
47  REMOVEFAILED = 0,
48  KEEPFAILED,
50  };
51 }
52 
53 
55 {
56 public:
57  static int version() { return 1; }
58 
60  {
61  myGroup = ""_UTsh;
62  myBatch = 0;
63  myPieceAttrib = "name"_UTsh;
64  myRemove = true;
65  myMode = 0;
66  myOutput = 1;
67  myKeepPrims = false;
68  myNoBoundMod = true;
69  myOneFacePerTet = false;
70  myPropNormal = true;
71  myInternAttrib = true;
72  myUseQuality = true;
73  myRadEdgeTol = 1.5;
74  myMinDihedralAngle = 10;
75  myUseTargetSizeAttrib = false;
76  myTargetSizeAttrib = "target_size"_UTsh;
77  myUseUniformMaxSize = false;
78  myUniformMaxSize = 0.1;
79  myUseMaxSizeAttrib = false;
80  myMaxSizeAttrib = "max_size"_UTsh;
81  myUseMaxIter = false;
82  myMaxIter = 100000;
83  myUseMaxSteiner = false;
84  myMaxSteiner = 1000;
85  myOptIterations = 2;
86  myOptEdgeFace = true;
87  myOptVtxSmooth = true;
88  myOptVtxMod = true;
89  myUseIsectColor = true;
90  myIsectPolyClr = UT_Vector3D(0.9,0,0);
91  myUseIsectGrp = true;
92  myIsectPolyGrp = "intersecting_polygon_grp"_UTsh;
93  myFailures = 0;
94  myRandomSeed = 3;
95  myPrecisionTol = 1e-09;
96  myDihedralAngleTol = 1e-05;
97  myMaxAttempts = 5;
98  myUseInvalidColor = true;
99  myInvalidPrimClr = UT_Vector3D(0.2,0,0);
100  myUseInvalidGrp = true;
101  myInvalidPrimGrp = "invalid_prim_grp"_UTsh;
102 
103  }
104 
105  explicit SOP_Tetrahedralize_2_0Parms(const SOP_Tetrahedralize_2_0Parms &) = default;
108  SOP_Tetrahedralize_2_0Parms &operator=(SOP_Tetrahedralize_2_0Parms &&) noexcept = default;
109 
111 
113  {
114  if (myGroup != src.myGroup) return false;
115  if (myBatch != src.myBatch) return false;
116  if (myPieceAttrib != src.myPieceAttrib) return false;
117  if (myRemove != src.myRemove) return false;
118  if (myMode != src.myMode) return false;
119  if (myOutput != src.myOutput) return false;
120  if (myKeepPrims != src.myKeepPrims) return false;
121  if (myNoBoundMod != src.myNoBoundMod) return false;
122  if (myOneFacePerTet != src.myOneFacePerTet) return false;
123  if (myPropNormal != src.myPropNormal) return false;
124  if (myInternAttrib != src.myInternAttrib) return false;
125  if (myUseQuality != src.myUseQuality) return false;
126  if (myRadEdgeTol != src.myRadEdgeTol) return false;
127  if (myMinDihedralAngle != src.myMinDihedralAngle) return false;
128  if (myUseTargetSizeAttrib != src.myUseTargetSizeAttrib) return false;
129  if (myTargetSizeAttrib != src.myTargetSizeAttrib) return false;
130  if (myUseUniformMaxSize != src.myUseUniformMaxSize) return false;
131  if (myUniformMaxSize != src.myUniformMaxSize) return false;
132  if (myUseMaxSizeAttrib != src.myUseMaxSizeAttrib) return false;
133  if (myMaxSizeAttrib != src.myMaxSizeAttrib) return false;
134  if (myUseMaxIter != src.myUseMaxIter) return false;
135  if (myMaxIter != src.myMaxIter) return false;
136  if (myUseMaxSteiner != src.myUseMaxSteiner) return false;
137  if (myMaxSteiner != src.myMaxSteiner) return false;
138  if (myOptIterations != src.myOptIterations) return false;
139  if (myOptEdgeFace != src.myOptEdgeFace) return false;
140  if (myOptVtxSmooth != src.myOptVtxSmooth) return false;
141  if (myOptVtxMod != src.myOptVtxMod) return false;
142  if (myUseIsectColor != src.myUseIsectColor) return false;
143  if (myIsectPolyClr != src.myIsectPolyClr) return false;
144  if (myUseIsectGrp != src.myUseIsectGrp) return false;
145  if (myIsectPolyGrp != src.myIsectPolyGrp) return false;
146  if (myFailures != src.myFailures) return false;
147  if (myRandomSeed != src.myRandomSeed) return false;
148  if (myPrecisionTol != src.myPrecisionTol) return false;
149  if (myDihedralAngleTol != src.myDihedralAngleTol) return false;
150  if (myMaxAttempts != src.myMaxAttempts) return false;
151  if (myUseInvalidColor != src.myUseInvalidColor) return false;
152  if (myInvalidPrimClr != src.myInvalidPrimClr) return false;
153  if (myUseInvalidGrp != src.myUseInvalidGrp) return false;
154  if (myInvalidPrimGrp != src.myInvalidPrimGrp) return false;
155 
156  return true;
157  }
159  {
160  return !operator==(src);
161  }
166 
167 
168 
169  void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
170  {
171  myGroup = ""_UTsh;
172  if (true)
173  graph->evalOpParm(myGroup, nodeidx, "group", time, 0);
174  myBatch = 0;
175  if (true)
176  graph->evalOpParm(myBatch, nodeidx, "batch", time, 0);
177  myPieceAttrib = "name"_UTsh;
178  if (true && ( (true&&!(((int64(getBatch())==0)))) ) )
179  graph->evalOpParm(myPieceAttrib, nodeidx, "pieceattrib", time, 0);
180  myRemove = true;
181  if (true)
182  graph->evalOpParm(myRemove, nodeidx, "remove", time, 0);
183  myMode = 0;
184  if (true)
185  graph->evalOpParm(myMode, nodeidx, "mode", time, 0);
186  myOutput = 1;
187  if (true && ( (true&&!(((int64(getMode())==3)))) ) )
188  graph->evalOpParm(myOutput, nodeidx, "output", time, 0);
189  myKeepPrims = false;
190  if (true && ( (true&&!(((int64(getMode())==3)))) ) )
191  graph->evalOpParm(myKeepPrims, nodeidx, "keepprims", time, 0);
192  myNoBoundMod = true;
193  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3)))) ) )
194  graph->evalOpParm(myNoBoundMod, nodeidx, "noboundmod", time, 0);
195  myOneFacePerTet = false;
196  if (true && ( (true&&!(((int64(getMode())!=0))||((int64(getOutput())==0))||((int64(getOutput())==2)))) ) )
197  graph->evalOpParm(myOneFacePerTet, nodeidx, "onefacepertet", time, 0);
198  myPropNormal = true;
199  if (true && ( (true&&!(((int64(getMode())!=0))||((int64(getOutput())==0))||((int64(getOutput())==2)))) ) )
200  graph->evalOpParm(myPropNormal, nodeidx, "propnormal", time, 0);
201  myInternAttrib = true;
202  if (true && ( (true&&!(((int64(getMode())!=0))||((int64(getOutput())==0))||((int64(getOutput())==2)))) ) )
203  graph->evalOpParm(myInternAttrib, nodeidx, "internattrib", time, 0);
204  myUseQuality = true;
205  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3)))) ) )
206  graph->evalOpParm(myUseQuality, nodeidx, "usequality", time, 0);
207  myRadEdgeTol = 1.5;
208  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0)))) ) )
209  graph->evalOpParm(myRadEdgeTol, nodeidx, "radedgetol", time, 0);
210  myMinDihedralAngle = 10;
211  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0)))) ) )
212  graph->evalOpParm(myMinDihedralAngle, nodeidx, "mindihedralang", time, 0);
213  myUseTargetSizeAttrib = false;
214  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0)))) ) )
215  graph->evalOpParm(myUseTargetSizeAttrib, nodeidx, "usetargetsizeattrib", time, 0);
216  myTargetSizeAttrib = "target_size"_UTsh;
217  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0))||((getUseTargetSizeAttrib()==0)))) ) )
218  graph->evalOpParm(myTargetSizeAttrib, nodeidx, "targetsizeattrib", time, 0);
219  myUseUniformMaxSize = false;
220  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0)))) ) )
221  graph->evalOpParm(myUseUniformMaxSize, nodeidx, "useuniformmaxsize", time, 0);
222  myUniformMaxSize = 0.1;
223  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0))||((getUseUniformMaxSize()==0)))) ) )
224  graph->evalOpParm(myUniformMaxSize, nodeidx, "uniformmaxsize", time, 0);
225  myUseMaxSizeAttrib = false;
226  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0))||((int64(getMode())!=1)))) ) )
227  graph->evalOpParm(myUseMaxSizeAttrib, nodeidx, "usemaxsizeattrib", time, 0);
228  myMaxSizeAttrib = "max_size"_UTsh;
229  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0))||((getUseMaxSizeAttrib()==0))||((int64(getMode())!=1)))) ) )
230  graph->evalOpParm(myMaxSizeAttrib, nodeidx, "maxsizeattrib", time, 0);
231  myUseMaxIter = false;
232  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0)))) ) )
233  graph->evalOpParm(myUseMaxIter, nodeidx, "usemaxiter", time, 0);
234  myMaxIter = 100000;
235  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0))||((getUseMaxIter()==0)))) ) )
236  graph->evalOpParm(myMaxIter, nodeidx, "maxiter", time, 0);
237  myUseMaxSteiner = false;
238  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0)))) ) )
239  graph->evalOpParm(myUseMaxSteiner, nodeidx, "usemaxsteiner", time, 0);
240  myMaxSteiner = 1000;
241  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3))||((getUseQuality()==0))||((getUseMaxSteiner()==0)))) ) )
242  graph->evalOpParm(myMaxSteiner, nodeidx, "maxsteiner", time, 0);
243  myOptIterations = 2;
244  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3)))) ) )
245  graph->evalOpParm(myOptIterations, nodeidx, "optiterations", time, 0);
246  myOptEdgeFace = true;
247  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3)))) ) )
248  graph->evalOpParm(myOptEdgeFace, nodeidx, "optedgeface", time, 0);
249  myOptVtxSmooth = true;
250  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3)))) ) )
251  graph->evalOpParm(myOptVtxSmooth, nodeidx, "optvtxsmooth", time, 0);
252  myOptVtxMod = true;
253  if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMode())==3)))) ) )
254  graph->evalOpParm(myOptVtxMod, nodeidx, "optvtxmod", time, 0);
255  myUseIsectColor = true;
256  if (true && ( (true&&!(((int64(getMode())!=3)))) ) )
257  graph->evalOpParm(myUseIsectColor, nodeidx, "useisectcolor", time, 0);
258  myIsectPolyClr = UT_Vector3D(0.9,0,0);
259  if (true && ( (true&&!(((getUseIsectColor()==0))||((int64(getMode())!=3)))) ) )
260  graph->evalOpParm(myIsectPolyClr, nodeidx, "isectpolyclr", time, 0);
261  myUseIsectGrp = true;
262  if (true && ( (true&&!(((int64(getMode())!=3)))) ) )
263  graph->evalOpParm(myUseIsectGrp, nodeidx, "useisectgrp", time, 0);
264  myIsectPolyGrp = "intersecting_polygon_grp"_UTsh;
265  if (true && ( (true&&!(((getUseIsectGrp()==0))||((int64(getMode())!=3)))) ) )
266  graph->evalOpParm(myIsectPolyGrp, nodeidx, "isectpolygrp", time, 0);
267  myFailures = 0;
268  if (true)
269  graph->evalOpParm(myFailures, nodeidx, "failures", time, 0);
270  myRandomSeed = 3;
271  if (true)
272  graph->evalOpParm(myRandomSeed, nodeidx, "randomseed", time, 0);
273  myPrecisionTol = 1e-09;
274  if (true)
275  graph->evalOpParm(myPrecisionTol, nodeidx, "precisiontol", time, 0);
276  myDihedralAngleTol = 1e-05;
277  if (true)
278  graph->evalOpParm(myDihedralAngleTol, nodeidx, "dihedralangtol", time, 0);
279  myMaxAttempts = 5;
280  if (true)
281  graph->evalOpParm(myMaxAttempts, nodeidx, "maxattempts", time, 0);
282  myUseInvalidColor = true;
283  if (true)
284  graph->evalOpParm(myUseInvalidColor, nodeidx, "useinvalidcolor", time, 0);
285  myInvalidPrimClr = UT_Vector3D(0.2,0,0);
286  if (true && ( (true&&!(((getUseInvalidColor()==0)))) ) )
287  graph->evalOpParm(myInvalidPrimClr, nodeidx, "invalidprimclr", time, 0);
288  myUseInvalidGrp = true;
289  if (true)
290  graph->evalOpParm(myUseInvalidGrp, nodeidx, "useinvalidgrp", time, 0);
291  myInvalidPrimGrp = "invalid_prim_grp"_UTsh;
292  if (true && ( (true&&!(((getUseInvalidGrp()==0)))) ) )
293  graph->evalOpParm(myInvalidPrimGrp, nodeidx, "invalidprimgrp", time, 0);
294 
295  }
296 
297 
298  void loadFromOpSubclass(const LoadParms &loadparms) override
299  {
300  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
301  }
302 
303 
304  void copyFrom(const OP_NodeParms *src) override
305  {
306  *this = *((const SOP_Tetrahedralize_2_0Parms *)src);
307  }
308 
309  template <typename T>
310  void
311  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
312  {
313  if (idx.size() < 1)
314  return;
315  UT_ASSERT(idx.size() == instance.size()+1);
316  if (idx.size() != instance.size()+1)
317  return;
318  switch (idx[0])
319  {
320  case 0:
321  coerceValue(value, myGroup);
322  break;
323  case 1:
324  coerceValue(value, myBatch);
325  break;
326  case 2:
327  coerceValue(value, myPieceAttrib);
328  break;
329  case 3:
330  coerceValue(value, myRemove);
331  break;
332  case 4:
333  coerceValue(value, myMode);
334  break;
335  case 5:
336  coerceValue(value, myOutput);
337  break;
338  case 6:
339  coerceValue(value, myKeepPrims);
340  break;
341  case 7:
342  coerceValue(value, myNoBoundMod);
343  break;
344  case 8:
345  coerceValue(value, myOneFacePerTet);
346  break;
347  case 9:
348  coerceValue(value, myPropNormal);
349  break;
350  case 10:
351  coerceValue(value, myInternAttrib);
352  break;
353  case 11:
354  coerceValue(value, myUseQuality);
355  break;
356  case 12:
357  coerceValue(value, myRadEdgeTol);
358  break;
359  case 13:
360  coerceValue(value, myMinDihedralAngle);
361  break;
362  case 14:
363  coerceValue(value, myUseTargetSizeAttrib);
364  break;
365  case 15:
366  coerceValue(value, myTargetSizeAttrib);
367  break;
368  case 16:
369  coerceValue(value, myUseUniformMaxSize);
370  break;
371  case 17:
372  coerceValue(value, myUniformMaxSize);
373  break;
374  case 18:
375  coerceValue(value, myUseMaxSizeAttrib);
376  break;
377  case 19:
378  coerceValue(value, myMaxSizeAttrib);
379  break;
380  case 20:
381  coerceValue(value, myUseMaxIter);
382  break;
383  case 21:
384  coerceValue(value, myMaxIter);
385  break;
386  case 22:
387  coerceValue(value, myUseMaxSteiner);
388  break;
389  case 23:
390  coerceValue(value, myMaxSteiner);
391  break;
392  case 24:
393  coerceValue(value, myOptIterations);
394  break;
395  case 25:
396  coerceValue(value, myOptEdgeFace);
397  break;
398  case 26:
399  coerceValue(value, myOptVtxSmooth);
400  break;
401  case 27:
402  coerceValue(value, myOptVtxMod);
403  break;
404  case 28:
405  coerceValue(value, myUseIsectColor);
406  break;
407  case 29:
408  coerceValue(value, myIsectPolyClr);
409  break;
410  case 30:
411  coerceValue(value, myUseIsectGrp);
412  break;
413  case 31:
414  coerceValue(value, myIsectPolyGrp);
415  break;
416  case 32:
417  coerceValue(value, myFailures);
418  break;
419  case 33:
420  coerceValue(value, myRandomSeed);
421  break;
422  case 34:
423  coerceValue(value, myPrecisionTol);
424  break;
425  case 35:
426  coerceValue(value, myDihedralAngleTol);
427  break;
428  case 36:
429  coerceValue(value, myMaxAttempts);
430  break;
431  case 37:
432  coerceValue(value, myUseInvalidColor);
433  break;
434  case 38:
435  coerceValue(value, myInvalidPrimClr);
436  break;
437  case 39:
438  coerceValue(value, myUseInvalidGrp);
439  break;
440  case 40:
441  coerceValue(value, myInvalidPrimGrp);
442  break;
443 
444  }
445  }
446 
447  bool isParmColorRamp(exint idx) const override
448  {
449  switch (idx)
450  {
451 
452  }
453  return false;
454  }
455 
456  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
457  { doGetParmValue(idx, instance, value); }
458  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
459  { doGetParmValue(idx, instance, value); }
460  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
461  { doGetParmValue(idx, instance, value); }
462  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
463  { doGetParmValue(idx, instance, value); }
464  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
465  { doGetParmValue(idx, instance, value); }
466  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
467  { doGetParmValue(idx, instance, value); }
468  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
469  { doGetParmValue(idx, instance, value); }
470  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
471  { doGetParmValue(idx, instance, value); }
472  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
473  { doGetParmValue(idx, instance, value); }
474  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
475  { doGetParmValue(idx, instance, value); }
476  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
477  { doGetParmValue(idx, instance, value); }
478 
479  template <typename T>
480  void
481  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
482  {
483  if (idx.size() < 1)
484  return;
485  UT_ASSERT(idx.size() == instance.size()+1);
486  if (idx.size() != instance.size()+1)
487  return;
488  switch (idx[0])
489  {
490  case 0:
491  coerceValue(myGroup, ( ( value ) ));
492  break;
493  case 1:
494  coerceValue(myBatch, clampMinValue(0, clampMaxValue(2, value ) ));
495  break;
496  case 2:
497  coerceValue(myPieceAttrib, ( ( value ) ));
498  break;
499  case 3:
500  coerceValue(myRemove, ( ( value ) ));
501  break;
502  case 4:
503  coerceValue(myMode, clampMinValue(0, clampMaxValue(3, value ) ));
504  break;
505  case 5:
506  coerceValue(myOutput, clampMinValue(0, clampMaxValue(3, value ) ));
507  break;
508  case 6:
509  coerceValue(myKeepPrims, ( ( value ) ));
510  break;
511  case 7:
512  coerceValue(myNoBoundMod, ( ( value ) ));
513  break;
514  case 8:
515  coerceValue(myOneFacePerTet, ( ( value ) ));
516  break;
517  case 9:
518  coerceValue(myPropNormal, ( ( value ) ));
519  break;
520  case 10:
521  coerceValue(myInternAttrib, ( ( value ) ));
522  break;
523  case 11:
524  coerceValue(myUseQuality, ( ( value ) ));
525  break;
526  case 12:
527  coerceValue(myRadEdgeTol, clampMinValue(0.612, ( value ) ));
528  break;
529  case 13:
530  coerceValue(myMinDihedralAngle, clampMinValue(0, clampMaxValue(60, value ) ));
531  break;
532  case 14:
533  coerceValue(myUseTargetSizeAttrib, ( ( value ) ));
534  break;
535  case 15:
536  coerceValue(myTargetSizeAttrib, ( ( value ) ));
537  break;
538  case 16:
539  coerceValue(myUseUniformMaxSize, ( ( value ) ));
540  break;
541  case 17:
542  coerceValue(myUniformMaxSize, clampMinValue(0, ( value ) ));
543  break;
544  case 18:
545  coerceValue(myUseMaxSizeAttrib, ( ( value ) ));
546  break;
547  case 19:
548  coerceValue(myMaxSizeAttrib, ( ( value ) ));
549  break;
550  case 20:
551  coerceValue(myUseMaxIter, ( ( value ) ));
552  break;
553  case 21:
554  coerceValue(myMaxIter, ( ( value ) ));
555  break;
556  case 22:
557  coerceValue(myUseMaxSteiner, ( ( value ) ));
558  break;
559  case 23:
560  coerceValue(myMaxSteiner, clampMinValue(0, ( value ) ));
561  break;
562  case 24:
563  coerceValue(myOptIterations, clampMinValue(0, clampMaxValue(9, value ) ));
564  break;
565  case 25:
566  coerceValue(myOptEdgeFace, ( ( value ) ));
567  break;
568  case 26:
569  coerceValue(myOptVtxSmooth, ( ( value ) ));
570  break;
571  case 27:
572  coerceValue(myOptVtxMod, ( ( value ) ));
573  break;
574  case 28:
575  coerceValue(myUseIsectColor, ( ( value ) ));
576  break;
577  case 29:
578  coerceValue(myIsectPolyClr, ( ( value ) ));
579  break;
580  case 30:
581  coerceValue(myUseIsectGrp, ( ( value ) ));
582  break;
583  case 31:
584  coerceValue(myIsectPolyGrp, ( ( value ) ));
585  break;
586  case 32:
587  coerceValue(myFailures, clampMinValue(0, clampMaxValue(2, value ) ));
588  break;
589  case 33:
590  coerceValue(myRandomSeed, clampMinValue(1, ( value ) ));
591  break;
592  case 34:
593  coerceValue(myPrecisionTol, clampMinValue(0, ( value ) ));
594  break;
595  case 35:
596  coerceValue(myDihedralAngleTol, clampMinValue(0, ( value ) ));
597  break;
598  case 36:
599  coerceValue(myMaxAttempts, ( ( value ) ));
600  break;
601  case 37:
602  coerceValue(myUseInvalidColor, ( ( value ) ));
603  break;
604  case 38:
605  coerceValue(myInvalidPrimClr, ( ( value ) ));
606  break;
607  case 39:
608  coerceValue(myUseInvalidGrp, ( ( value ) ));
609  break;
610  case 40:
611  coerceValue(myInvalidPrimGrp, ( ( value ) ));
612  break;
613 
614  }
615  }
616 
617  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
618  { doSetParmValue(idx, instance, value); }
619  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
620  { doSetParmValue(idx, instance, value); }
621  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
622  { doSetParmValue(idx, instance, value); }
623  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
624  { doSetParmValue(idx, instance, value); }
625  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
626  { doSetParmValue(idx, instance, value); }
627  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
628  { doSetParmValue(idx, instance, value); }
629  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
630  { doSetParmValue(idx, instance, value); }
631  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
632  { doSetParmValue(idx, instance, value); }
633  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
634  { doSetParmValue(idx, instance, value); }
635  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
636  { doSetParmValue(idx, instance, value); }
637  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
638  { doSetParmValue(idx, instance, value); }
639 
640  exint getNestNumParms(TempIndex idx) const override
641  {
642  if (idx.size() == 0)
643  return 41;
644  switch (idx[0])
645  {
646 
647  }
648  // Invalid
649  return 0;
650  }
651 
652  const char *getNestParmName(TempIndex fieldnum) const override
653  {
654  if (fieldnum.size() < 1)
655  return 0;
656  switch (fieldnum[0])
657  {
658  case 0:
659  return "group";
660  case 1:
661  return "batch";
662  case 2:
663  return "pieceattrib";
664  case 3:
665  return "remove";
666  case 4:
667  return "mode";
668  case 5:
669  return "output";
670  case 6:
671  return "keepprims";
672  case 7:
673  return "noboundmod";
674  case 8:
675  return "onefacepertet";
676  case 9:
677  return "propnormal";
678  case 10:
679  return "internattrib";
680  case 11:
681  return "usequality";
682  case 12:
683  return "radedgetol";
684  case 13:
685  return "mindihedralang";
686  case 14:
687  return "usetargetsizeattrib";
688  case 15:
689  return "targetsizeattrib";
690  case 16:
691  return "useuniformmaxsize";
692  case 17:
693  return "uniformmaxsize";
694  case 18:
695  return "usemaxsizeattrib";
696  case 19:
697  return "maxsizeattrib";
698  case 20:
699  return "usemaxiter";
700  case 21:
701  return "maxiter";
702  case 22:
703  return "usemaxsteiner";
704  case 23:
705  return "maxsteiner";
706  case 24:
707  return "optiterations";
708  case 25:
709  return "optedgeface";
710  case 26:
711  return "optvtxsmooth";
712  case 27:
713  return "optvtxmod";
714  case 28:
715  return "useisectcolor";
716  case 29:
717  return "isectpolyclr";
718  case 30:
719  return "useisectgrp";
720  case 31:
721  return "isectpolygrp";
722  case 32:
723  return "failures";
724  case 33:
725  return "randomseed";
726  case 34:
727  return "precisiontol";
728  case 35:
729  return "dihedralangtol";
730  case 36:
731  return "maxattempts";
732  case 37:
733  return "useinvalidcolor";
734  case 38:
735  return "invalidprimclr";
736  case 39:
737  return "useinvalidgrp";
738  case 40:
739  return "invalidprimgrp";
740 
741  }
742  return 0;
743  }
744 
745  ParmType getNestParmType(TempIndex fieldnum) const override
746  {
747  if (fieldnum.size() < 1)
748  return PARM_UNSUPPORTED;
749  switch (fieldnum[0])
750  {
751  case 0:
752  return PARM_STRING;
753  case 1:
754  return PARM_INTEGER;
755  case 2:
756  return PARM_STRING;
757  case 3:
758  return PARM_INTEGER;
759  case 4:
760  return PARM_INTEGER;
761  case 5:
762  return PARM_INTEGER;
763  case 6:
764  return PARM_INTEGER;
765  case 7:
766  return PARM_INTEGER;
767  case 8:
768  return PARM_INTEGER;
769  case 9:
770  return PARM_INTEGER;
771  case 10:
772  return PARM_INTEGER;
773  case 11:
774  return PARM_INTEGER;
775  case 12:
776  return PARM_FLOAT;
777  case 13:
778  return PARM_FLOAT;
779  case 14:
780  return PARM_INTEGER;
781  case 15:
782  return PARM_STRING;
783  case 16:
784  return PARM_INTEGER;
785  case 17:
786  return PARM_FLOAT;
787  case 18:
788  return PARM_INTEGER;
789  case 19:
790  return PARM_STRING;
791  case 20:
792  return PARM_INTEGER;
793  case 21:
794  return PARM_INTEGER;
795  case 22:
796  return PARM_INTEGER;
797  case 23:
798  return PARM_INTEGER;
799  case 24:
800  return PARM_INTEGER;
801  case 25:
802  return PARM_INTEGER;
803  case 26:
804  return PARM_INTEGER;
805  case 27:
806  return PARM_INTEGER;
807  case 28:
808  return PARM_INTEGER;
809  case 29:
810  return PARM_VECTOR3;
811  case 30:
812  return PARM_INTEGER;
813  case 31:
814  return PARM_STRING;
815  case 32:
816  return PARM_INTEGER;
817  case 33:
818  return PARM_INTEGER;
819  case 34:
820  return PARM_FLOAT;
821  case 35:
822  return PARM_FLOAT;
823  case 36:
824  return PARM_INTEGER;
825  case 37:
826  return PARM_INTEGER;
827  case 38:
828  return PARM_VECTOR3;
829  case 39:
830  return PARM_INTEGER;
831  case 40:
832  return PARM_STRING;
833 
834  }
835  return PARM_UNSUPPORTED;
836  }
837 
838  // Boiler plate to load individual types.
839  static void loadData(UT_IStream &is, int64 &v)
840  { is.bread(&v, 1); }
841  static void loadData(UT_IStream &is, bool &v)
842  { int64 iv; is.bread(&iv, 1); v = iv; }
843  static void loadData(UT_IStream &is, fpreal64 &v)
844  { is.bread<fpreal64>(&v, 1); }
845  static void loadData(UT_IStream &is, UT_Vector2D &v)
846  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
847  static void loadData(UT_IStream &is, UT_Vector3D &v)
848  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
849  is.bread<fpreal64>(&v.z(), 1); }
850  static void loadData(UT_IStream &is, UT_Vector4D &v)
851  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
852  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
853  static void loadData(UT_IStream &is, UT_Matrix2D &v)
854  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
855  static void loadData(UT_IStream &is, UT_Matrix3D &v)
856  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
857  static void loadData(UT_IStream &is, UT_Matrix4D &v)
858  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
859  static void loadData(UT_IStream &is, UT_Vector2I &v)
860  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
861  static void loadData(UT_IStream &is, UT_Vector3I &v)
862  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
863  is.bread<int64>(&v.z(), 1); }
864  static void loadData(UT_IStream &is, UT_Vector4I &v)
865  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
866  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
868  { is.bread(v); }
870  { UT_StringHolder rampdata;
871  loadData(is, rampdata);
872  if (rampdata.isstring())
873  {
874  v.reset(new UT_Ramp());
875  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
876  v->load(istr);
877  }
878  else v.reset();
879  }
882  loadData(is, data);
883  if (data.isstring())
884  {
885  // Find the data type.
886  const char *colon = UT_StringWrap(data).findChar(':');
887  if (colon)
888  {
889  int typelen = colon - data.buffer();
891  type.strncpy(data.buffer(), typelen);
892  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
893 
894  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
895  }
896  }
897  else v.reset();
898  }
899 
900  static void saveData(std::ostream &os, int64 v)
901  { UTwrite(os, &v); }
902  static void saveData(std::ostream &os, bool v)
903  { int64 iv = v; UTwrite(os, &iv); }
904  static void saveData(std::ostream &os, fpreal64 v)
905  { UTwrite<fpreal64>(os, &v); }
906  static void saveData(std::ostream &os, UT_Vector2D v)
907  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
908  static void saveData(std::ostream &os, UT_Vector3D v)
909  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
910  UTwrite<fpreal64>(os, &v.z()); }
911  static void saveData(std::ostream &os, UT_Vector4D v)
912  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
913  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
914  static void saveData(std::ostream &os, UT_Matrix2D v)
916  static void saveData(std::ostream &os, UT_Matrix3D v)
918  static void saveData(std::ostream &os, UT_Matrix4D v)
920  static void saveData(std::ostream &os, UT_StringHolder s)
921  { UT_StringWrap(s).saveBinary(os); }
922  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
924  UT_OStringStream ostr;
925  if (s) s->save(ostr);
926  result = ostr.str();
927  saveData(os, result);
928  }
929  static void saveData(std::ostream &os, PRM_DataItemHandle s)
931  UT_OStringStream ostr;
932  if (s)
933  {
934  ostr << s->getDataTypeToken();
935  ostr << ":";
936  s->saveBinary(ostr);
937  }
938  result = ostr.str();
939  saveData(os, result);
940  }
941 
942 
943  void save(std::ostream &os) const
944  {
945  int32 v = version();
946  UTwrite(os, &v);
947  saveData(os, myGroup);
948  saveData(os, myBatch);
949  saveData(os, myPieceAttrib);
950  saveData(os, myRemove);
951  saveData(os, myMode);
952  saveData(os, myOutput);
953  saveData(os, myKeepPrims);
954  saveData(os, myNoBoundMod);
955  saveData(os, myOneFacePerTet);
956  saveData(os, myPropNormal);
957  saveData(os, myInternAttrib);
958  saveData(os, myUseQuality);
959  saveData(os, myRadEdgeTol);
960  saveData(os, myMinDihedralAngle);
961  saveData(os, myUseTargetSizeAttrib);
962  saveData(os, myTargetSizeAttrib);
963  saveData(os, myUseUniformMaxSize);
964  saveData(os, myUniformMaxSize);
965  saveData(os, myUseMaxSizeAttrib);
966  saveData(os, myMaxSizeAttrib);
967  saveData(os, myUseMaxIter);
968  saveData(os, myMaxIter);
969  saveData(os, myUseMaxSteiner);
970  saveData(os, myMaxSteiner);
971  saveData(os, myOptIterations);
972  saveData(os, myOptEdgeFace);
973  saveData(os, myOptVtxSmooth);
974  saveData(os, myOptVtxMod);
975  saveData(os, myUseIsectColor);
976  saveData(os, myIsectPolyClr);
977  saveData(os, myUseIsectGrp);
978  saveData(os, myIsectPolyGrp);
979  saveData(os, myFailures);
980  saveData(os, myRandomSeed);
981  saveData(os, myPrecisionTol);
982  saveData(os, myDihedralAngleTol);
983  saveData(os, myMaxAttempts);
984  saveData(os, myUseInvalidColor);
985  saveData(os, myInvalidPrimClr);
986  saveData(os, myUseInvalidGrp);
987  saveData(os, myInvalidPrimGrp);
988 
989  }
990 
991  bool load(UT_IStream &is)
992  {
993  int32 v;
994  is.bread(&v, 1);
995  if (version() != v)
996  {
997  // Fail incompatible versions
998  return false;
999  }
1000  loadData(is, myGroup);
1001  loadData(is, myBatch);
1002  loadData(is, myPieceAttrib);
1003  loadData(is, myRemove);
1004  loadData(is, myMode);
1005  loadData(is, myOutput);
1006  loadData(is, myKeepPrims);
1007  loadData(is, myNoBoundMod);
1008  loadData(is, myOneFacePerTet);
1009  loadData(is, myPropNormal);
1010  loadData(is, myInternAttrib);
1011  loadData(is, myUseQuality);
1012  loadData(is, myRadEdgeTol);
1013  loadData(is, myMinDihedralAngle);
1014  loadData(is, myUseTargetSizeAttrib);
1015  loadData(is, myTargetSizeAttrib);
1016  loadData(is, myUseUniformMaxSize);
1017  loadData(is, myUniformMaxSize);
1018  loadData(is, myUseMaxSizeAttrib);
1019  loadData(is, myMaxSizeAttrib);
1020  loadData(is, myUseMaxIter);
1021  loadData(is, myMaxIter);
1022  loadData(is, myUseMaxSteiner);
1023  loadData(is, myMaxSteiner);
1024  loadData(is, myOptIterations);
1025  loadData(is, myOptEdgeFace);
1026  loadData(is, myOptVtxSmooth);
1027  loadData(is, myOptVtxMod);
1028  loadData(is, myUseIsectColor);
1029  loadData(is, myIsectPolyClr);
1030  loadData(is, myUseIsectGrp);
1031  loadData(is, myIsectPolyGrp);
1032  loadData(is, myFailures);
1033  loadData(is, myRandomSeed);
1034  loadData(is, myPrecisionTol);
1035  loadData(is, myDihedralAngleTol);
1036  loadData(is, myMaxAttempts);
1037  loadData(is, myUseInvalidColor);
1038  loadData(is, myInvalidPrimClr);
1039  loadData(is, myUseInvalidGrp);
1040  loadData(is, myInvalidPrimGrp);
1041 
1042  return true;
1043  }
1044 
1045  const UT_StringHolder & getGroup() const { return myGroup; }
1046  void setGroup(const UT_StringHolder & val) { myGroup = val; }
1048  {
1049  SOP_Node *thissop = cookparms.getNode();
1050  if (!thissop) return getGroup();
1052  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
1053  return result;
1054  }
1055  Batch getBatch() const { return Batch(myBatch); }
1056  void setBatch(Batch val) { myBatch = int64(val); }
1057  Batch opBatch(const SOP_NodeVerb::CookParms &cookparms) const
1058  {
1059  SOP_Node *thissop = cookparms.getNode();
1060  if (!thissop) return getBatch();
1061  int64 result;
1062  OP_Utils::evalOpParm(result, thissop, "batch", cookparms.getCookTime(), 0);
1063  return Batch(result);
1064  }
1065  const UT_StringHolder & getPieceAttrib() const { return myPieceAttrib; }
1066  void setPieceAttrib(const UT_StringHolder & val) { myPieceAttrib = val; }
1068  {
1069  SOP_Node *thissop = cookparms.getNode();
1070  if (!thissop) return getPieceAttrib();
1072  OP_Utils::evalOpParm(result, thissop, "pieceattrib", cookparms.getCookTime(), 0);
1073  return result;
1074  }
1075  bool getRemove() const { return myRemove; }
1076  void setRemove(bool val) { myRemove = val; }
1077  bool opRemove(const SOP_NodeVerb::CookParms &cookparms) const
1078  {
1079  SOP_Node *thissop = cookparms.getNode();
1080  if (!thissop) return getRemove();
1081  bool result;
1082  OP_Utils::evalOpParm(result, thissop, "remove", cookparms.getCookTime(), 0);
1083  return result;
1084  }
1085  Mode getMode() const { return Mode(myMode); }
1086  void setMode(Mode val) { myMode = int64(val); }
1087  Mode opMode(const SOP_NodeVerb::CookParms &cookparms) const
1088  {
1089  SOP_Node *thissop = cookparms.getNode();
1090  if (!thissop) return getMode();
1091  int64 result;
1092  OP_Utils::evalOpParm(result, thissop, "mode", cookparms.getCookTime(), 0);
1093  return Mode(result);
1094  }
1095  Output getOutput() const { return Output(myOutput); }
1096  void setOutput(Output val) { myOutput = int64(val); }
1097  Output opOutput(const SOP_NodeVerb::CookParms &cookparms) const
1098  {
1099  SOP_Node *thissop = cookparms.getNode();
1100  if (!thissop) return getOutput();
1101  int64 result;
1102  OP_Utils::evalOpParm(result, thissop, "output", cookparms.getCookTime(), 0);
1103  return Output(result);
1104  }
1105  bool getKeepPrims() const { return myKeepPrims; }
1106  void setKeepPrims(bool val) { myKeepPrims = val; }
1107  bool opKeepPrims(const SOP_NodeVerb::CookParms &cookparms) const
1108  {
1109  SOP_Node *thissop = cookparms.getNode();
1110  if (!thissop) return getKeepPrims();
1111  bool result;
1112  OP_Utils::evalOpParm(result, thissop, "keepprims", cookparms.getCookTime(), 0);
1113  return result;
1114  }
1115  bool getNoBoundMod() const { return myNoBoundMod; }
1116  void setNoBoundMod(bool val) { myNoBoundMod = val; }
1117  bool opNoBoundMod(const SOP_NodeVerb::CookParms &cookparms) const
1118  {
1119  SOP_Node *thissop = cookparms.getNode();
1120  if (!thissop) return getNoBoundMod();
1121  bool result;
1122  OP_Utils::evalOpParm(result, thissop, "noboundmod", cookparms.getCookTime(), 0);
1123  return result;
1124  }
1125  bool getOneFacePerTet() const { return myOneFacePerTet; }
1126  void setOneFacePerTet(bool val) { myOneFacePerTet = val; }
1127  bool opOneFacePerTet(const SOP_NodeVerb::CookParms &cookparms) const
1128  {
1129  SOP_Node *thissop = cookparms.getNode();
1130  if (!thissop) return getOneFacePerTet();
1131  bool result;
1132  OP_Utils::evalOpParm(result, thissop, "onefacepertet", cookparms.getCookTime(), 0);
1133  return result;
1134  }
1135  bool getPropNormal() const { return myPropNormal; }
1136  void setPropNormal(bool val) { myPropNormal = val; }
1137  bool opPropNormal(const SOP_NodeVerb::CookParms &cookparms) const
1138  {
1139  SOP_Node *thissop = cookparms.getNode();
1140  if (!thissop) return getPropNormal();
1141  bool result;
1142  OP_Utils::evalOpParm(result, thissop, "propnormal", cookparms.getCookTime(), 0);
1143  return result;
1144  }
1145  bool getInternAttrib() const { return myInternAttrib; }
1146  void setInternAttrib(bool val) { myInternAttrib = val; }
1147  bool opInternAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1148  {
1149  SOP_Node *thissop = cookparms.getNode();
1150  if (!thissop) return getInternAttrib();
1151  bool result;
1152  OP_Utils::evalOpParm(result, thissop, "internattrib", cookparms.getCookTime(), 0);
1153  return result;
1154  }
1155  bool getUseQuality() const { return myUseQuality; }
1156  void setUseQuality(bool val) { myUseQuality = val; }
1157  bool opUseQuality(const SOP_NodeVerb::CookParms &cookparms) const
1158  {
1159  SOP_Node *thissop = cookparms.getNode();
1160  if (!thissop) return getUseQuality();
1161  bool result;
1162  OP_Utils::evalOpParm(result, thissop, "usequality", cookparms.getCookTime(), 0);
1163  return result;
1164  }
1165  fpreal64 getRadEdgeTol() const { return myRadEdgeTol; }
1166  void setRadEdgeTol(fpreal64 val) { myRadEdgeTol = val; }
1168  {
1169  SOP_Node *thissop = cookparms.getNode();
1170  if (!thissop) return getRadEdgeTol();
1171  fpreal64 result;
1172  OP_Utils::evalOpParm(result, thissop, "radedgetol", cookparms.getCookTime(), 0);
1173  return result;
1174  }
1175  fpreal64 getMinDihedralAngle() const { return myMinDihedralAngle; }
1176  void setMinDihedralAngle(fpreal64 val) { myMinDihedralAngle = val; }
1178  {
1179  SOP_Node *thissop = cookparms.getNode();
1180  if (!thissop) return getMinDihedralAngle();
1181  fpreal64 result;
1182  OP_Utils::evalOpParm(result, thissop, "mindihedralang", cookparms.getCookTime(), 0);
1183  return result;
1184  }
1185  bool getUseTargetSizeAttrib() const { return myUseTargetSizeAttrib; }
1186  void setUseTargetSizeAttrib(bool val) { myUseTargetSizeAttrib = val; }
1187  bool opUseTargetSizeAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1188  {
1189  SOP_Node *thissop = cookparms.getNode();
1190  if (!thissop) return getUseTargetSizeAttrib();
1191  bool result;
1192  OP_Utils::evalOpParm(result, thissop, "usetargetsizeattrib", cookparms.getCookTime(), 0);
1193  return result;
1194  }
1195  const UT_StringHolder & getTargetSizeAttrib() const { return myTargetSizeAttrib; }
1196  void setTargetSizeAttrib(const UT_StringHolder & val) { myTargetSizeAttrib = val; }
1198  {
1199  SOP_Node *thissop = cookparms.getNode();
1200  if (!thissop) return getTargetSizeAttrib();
1202  OP_Utils::evalOpParm(result, thissop, "targetsizeattrib", cookparms.getCookTime(), 0);
1203  return result;
1204  }
1205  bool getUseUniformMaxSize() const { return myUseUniformMaxSize; }
1206  void setUseUniformMaxSize(bool val) { myUseUniformMaxSize = val; }
1207  bool opUseUniformMaxSize(const SOP_NodeVerb::CookParms &cookparms) const
1208  {
1209  SOP_Node *thissop = cookparms.getNode();
1210  if (!thissop) return getUseUniformMaxSize();
1211  bool result;
1212  OP_Utils::evalOpParm(result, thissop, "useuniformmaxsize", cookparms.getCookTime(), 0);
1213  return result;
1214  }
1215  fpreal64 getUniformMaxSize() const { return myUniformMaxSize; }
1216  void setUniformMaxSize(fpreal64 val) { myUniformMaxSize = val; }
1218  {
1219  SOP_Node *thissop = cookparms.getNode();
1220  if (!thissop) return getUniformMaxSize();
1221  fpreal64 result;
1222  OP_Utils::evalOpParm(result, thissop, "uniformmaxsize", cookparms.getCookTime(), 0);
1223  return result;
1224  }
1225  bool getUseMaxSizeAttrib() const { return myUseMaxSizeAttrib; }
1226  void setUseMaxSizeAttrib(bool val) { myUseMaxSizeAttrib = val; }
1227  bool opUseMaxSizeAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1228  {
1229  SOP_Node *thissop = cookparms.getNode();
1230  if (!thissop) return getUseMaxSizeAttrib();
1231  bool result;
1232  OP_Utils::evalOpParm(result, thissop, "usemaxsizeattrib", cookparms.getCookTime(), 0);
1233  return result;
1234  }
1235  const UT_StringHolder & getMaxSizeAttrib() const { return myMaxSizeAttrib; }
1236  void setMaxSizeAttrib(const UT_StringHolder & val) { myMaxSizeAttrib = val; }
1238  {
1239  SOP_Node *thissop = cookparms.getNode();
1240  if (!thissop) return getMaxSizeAttrib();
1242  OP_Utils::evalOpParm(result, thissop, "maxsizeattrib", cookparms.getCookTime(), 0);
1243  return result;
1244  }
1245  bool getUseMaxIter() const { return myUseMaxIter; }
1246  void setUseMaxIter(bool val) { myUseMaxIter = val; }
1247  bool opUseMaxIter(const SOP_NodeVerb::CookParms &cookparms) const
1248  {
1249  SOP_Node *thissop = cookparms.getNode();
1250  if (!thissop) return getUseMaxIter();
1251  bool result;
1252  OP_Utils::evalOpParm(result, thissop, "usemaxiter", cookparms.getCookTime(), 0);
1253  return result;
1254  }
1255  int64 getMaxIter() const { return myMaxIter; }
1256  void setMaxIter(int64 val) { myMaxIter = val; }
1257  int64 opMaxIter(const SOP_NodeVerb::CookParms &cookparms) const
1258  {
1259  SOP_Node *thissop = cookparms.getNode();
1260  if (!thissop) return getMaxIter();
1261  int64 result;
1262  OP_Utils::evalOpParm(result, thissop, "maxiter", cookparms.getCookTime(), 0);
1263  return result;
1264  }
1265  bool getUseMaxSteiner() const { return myUseMaxSteiner; }
1266  void setUseMaxSteiner(bool val) { myUseMaxSteiner = val; }
1267  bool opUseMaxSteiner(const SOP_NodeVerb::CookParms &cookparms) const
1268  {
1269  SOP_Node *thissop = cookparms.getNode();
1270  if (!thissop) return getUseMaxSteiner();
1271  bool result;
1272  OP_Utils::evalOpParm(result, thissop, "usemaxsteiner", cookparms.getCookTime(), 0);
1273  return result;
1274  }
1275  int64 getMaxSteiner() const { return myMaxSteiner; }
1276  void setMaxSteiner(int64 val) { myMaxSteiner = val; }
1278  {
1279  SOP_Node *thissop = cookparms.getNode();
1280  if (!thissop) return getMaxSteiner();
1281  int64 result;
1282  OP_Utils::evalOpParm(result, thissop, "maxsteiner", cookparms.getCookTime(), 0);
1283  return result;
1284  }
1285  int64 getOptIterations() const { return myOptIterations; }
1286  void setOptIterations(int64 val) { myOptIterations = val; }
1288  {
1289  SOP_Node *thissop = cookparms.getNode();
1290  if (!thissop) return getOptIterations();
1291  int64 result;
1292  OP_Utils::evalOpParm(result, thissop, "optiterations", cookparms.getCookTime(), 0);
1293  return result;
1294  }
1295  bool getOptEdgeFace() const { return myOptEdgeFace; }
1296  void setOptEdgeFace(bool val) { myOptEdgeFace = val; }
1297  bool opOptEdgeFace(const SOP_NodeVerb::CookParms &cookparms) const
1298  {
1299  SOP_Node *thissop = cookparms.getNode();
1300  if (!thissop) return getOptEdgeFace();
1301  bool result;
1302  OP_Utils::evalOpParm(result, thissop, "optedgeface", cookparms.getCookTime(), 0);
1303  return result;
1304  }
1305  bool getOptVtxSmooth() const { return myOptVtxSmooth; }
1306  void setOptVtxSmooth(bool val) { myOptVtxSmooth = val; }
1307  bool opOptVtxSmooth(const SOP_NodeVerb::CookParms &cookparms) const
1308  {
1309  SOP_Node *thissop = cookparms.getNode();
1310  if (!thissop) return getOptVtxSmooth();
1311  bool result;
1312  OP_Utils::evalOpParm(result, thissop, "optvtxsmooth", cookparms.getCookTime(), 0);
1313  return result;
1314  }
1315  bool getOptVtxMod() const { return myOptVtxMod; }
1316  void setOptVtxMod(bool val) { myOptVtxMod = val; }
1317  bool opOptVtxMod(const SOP_NodeVerb::CookParms &cookparms) const
1318  {
1319  SOP_Node *thissop = cookparms.getNode();
1320  if (!thissop) return getOptVtxMod();
1321  bool result;
1322  OP_Utils::evalOpParm(result, thissop, "optvtxmod", cookparms.getCookTime(), 0);
1323  return result;
1324  }
1325  bool getUseIsectColor() const { return myUseIsectColor; }
1326  void setUseIsectColor(bool val) { myUseIsectColor = val; }
1327  bool opUseIsectColor(const SOP_NodeVerb::CookParms &cookparms) const
1328  {
1329  SOP_Node *thissop = cookparms.getNode();
1330  if (!thissop) return getUseIsectColor();
1331  bool result;
1332  OP_Utils::evalOpParm(result, thissop, "useisectcolor", cookparms.getCookTime(), 0);
1333  return result;
1334  }
1335  UT_Vector3D getIsectPolyClr() const { return myIsectPolyClr; }
1336  void setIsectPolyClr(UT_Vector3D val) { myIsectPolyClr = val; }
1338  {
1339  SOP_Node *thissop = cookparms.getNode();
1340  if (!thissop) return getIsectPolyClr();
1342  OP_Utils::evalOpParm(result, thissop, "isectpolyclr", cookparms.getCookTime(), 0);
1343  return result;
1344  }
1345  bool getUseIsectGrp() const { return myUseIsectGrp; }
1346  void setUseIsectGrp(bool val) { myUseIsectGrp = val; }
1347  bool opUseIsectGrp(const SOP_NodeVerb::CookParms &cookparms) const
1348  {
1349  SOP_Node *thissop = cookparms.getNode();
1350  if (!thissop) return getUseIsectGrp();
1351  bool result;
1352  OP_Utils::evalOpParm(result, thissop, "useisectgrp", cookparms.getCookTime(), 0);
1353  return result;
1354  }
1355  const UT_StringHolder & getIsectPolyGrp() const { return myIsectPolyGrp; }
1356  void setIsectPolyGrp(const UT_StringHolder & val) { myIsectPolyGrp = val; }
1358  {
1359  SOP_Node *thissop = cookparms.getNode();
1360  if (!thissop) return getIsectPolyGrp();
1362  OP_Utils::evalOpParm(result, thissop, "isectpolygrp", cookparms.getCookTime(), 0);
1363  return result;
1364  }
1365  Failures getFailures() const { return Failures(myFailures); }
1366  void setFailures(Failures val) { myFailures = int64(val); }
1368  {
1369  SOP_Node *thissop = cookparms.getNode();
1370  if (!thissop) return getFailures();
1371  int64 result;
1372  OP_Utils::evalOpParm(result, thissop, "failures", cookparms.getCookTime(), 0);
1373  return Failures(result);
1374  }
1375  int64 getRandomSeed() const { return myRandomSeed; }
1376  void setRandomSeed(int64 val) { myRandomSeed = val; }
1378  {
1379  SOP_Node *thissop = cookparms.getNode();
1380  if (!thissop) return getRandomSeed();
1381  int64 result;
1382  OP_Utils::evalOpParm(result, thissop, "randomseed", cookparms.getCookTime(), 0);
1383  return result;
1384  }
1385  fpreal64 getPrecisionTol() const { return myPrecisionTol; }
1386  void setPrecisionTol(fpreal64 val) { myPrecisionTol = val; }
1388  {
1389  SOP_Node *thissop = cookparms.getNode();
1390  if (!thissop) return getPrecisionTol();
1391  fpreal64 result;
1392  OP_Utils::evalOpParm(result, thissop, "precisiontol", cookparms.getCookTime(), 0);
1393  return result;
1394  }
1395  fpreal64 getDihedralAngleTol() const { return myDihedralAngleTol; }
1396  void setDihedralAngleTol(fpreal64 val) { myDihedralAngleTol = val; }
1398  {
1399  SOP_Node *thissop = cookparms.getNode();
1400  if (!thissop) return getDihedralAngleTol();
1401  fpreal64 result;
1402  OP_Utils::evalOpParm(result, thissop, "dihedralangtol", cookparms.getCookTime(), 0);
1403  return result;
1404  }
1405  int64 getMaxAttempts() const { return myMaxAttempts; }
1406  void setMaxAttempts(int64 val) { myMaxAttempts = val; }
1408  {
1409  SOP_Node *thissop = cookparms.getNode();
1410  if (!thissop) return getMaxAttempts();
1411  int64 result;
1412  OP_Utils::evalOpParm(result, thissop, "maxattempts", cookparms.getCookTime(), 0);
1413  return result;
1414  }
1415  bool getUseInvalidColor() const { return myUseInvalidColor; }
1416  void setUseInvalidColor(bool val) { myUseInvalidColor = val; }
1417  bool opUseInvalidColor(const SOP_NodeVerb::CookParms &cookparms) const
1418  {
1419  SOP_Node *thissop = cookparms.getNode();
1420  if (!thissop) return getUseInvalidColor();
1421  bool result;
1422  OP_Utils::evalOpParm(result, thissop, "useinvalidcolor", cookparms.getCookTime(), 0);
1423  return result;
1424  }
1425  UT_Vector3D getInvalidPrimClr() const { return myInvalidPrimClr; }
1426  void setInvalidPrimClr(UT_Vector3D val) { myInvalidPrimClr = val; }
1428  {
1429  SOP_Node *thissop = cookparms.getNode();
1430  if (!thissop) return getInvalidPrimClr();
1432  OP_Utils::evalOpParm(result, thissop, "invalidprimclr", cookparms.getCookTime(), 0);
1433  return result;
1434  }
1435  bool getUseInvalidGrp() const { return myUseInvalidGrp; }
1436  void setUseInvalidGrp(bool val) { myUseInvalidGrp = val; }
1437  bool opUseInvalidGrp(const SOP_NodeVerb::CookParms &cookparms) const
1438  {
1439  SOP_Node *thissop = cookparms.getNode();
1440  if (!thissop) return getUseInvalidGrp();
1441  bool result;
1442  OP_Utils::evalOpParm(result, thissop, "useinvalidgrp", cookparms.getCookTime(), 0);
1443  return result;
1444  }
1445  const UT_StringHolder & getInvalidPrimGrp() const { return myInvalidPrimGrp; }
1446  void setInvalidPrimGrp(const UT_StringHolder & val) { myInvalidPrimGrp = val; }
1448  {
1449  SOP_Node *thissop = cookparms.getNode();
1450  if (!thissop) return getInvalidPrimGrp();
1452  OP_Utils::evalOpParm(result, thissop, "invalidprimgrp", cookparms.getCookTime(), 0);
1453  return result;
1454  }
1455 
1456 private:
1457  UT_StringHolder myGroup;
1458  int64 myBatch;
1459  UT_StringHolder myPieceAttrib;
1460  bool myRemove;
1461  int64 myMode;
1462  int64 myOutput;
1463  bool myKeepPrims;
1464  bool myNoBoundMod;
1465  bool myOneFacePerTet;
1466  bool myPropNormal;
1467  bool myInternAttrib;
1468  bool myUseQuality;
1469  fpreal64 myRadEdgeTol;
1470  fpreal64 myMinDihedralAngle;
1471  bool myUseTargetSizeAttrib;
1472  UT_StringHolder myTargetSizeAttrib;
1473  bool myUseUniformMaxSize;
1474  fpreal64 myUniformMaxSize;
1475  bool myUseMaxSizeAttrib;
1476  UT_StringHolder myMaxSizeAttrib;
1477  bool myUseMaxIter;
1478  int64 myMaxIter;
1479  bool myUseMaxSteiner;
1480  int64 myMaxSteiner;
1481  int64 myOptIterations;
1482  bool myOptEdgeFace;
1483  bool myOptVtxSmooth;
1484  bool myOptVtxMod;
1485  bool myUseIsectColor;
1486  UT_Vector3D myIsectPolyClr;
1487  bool myUseIsectGrp;
1488  UT_StringHolder myIsectPolyGrp;
1489  int64 myFailures;
1490  int64 myRandomSeed;
1491  fpreal64 myPrecisionTol;
1492  fpreal64 myDihedralAngleTol;
1493  int64 myMaxAttempts;
1494  bool myUseInvalidColor;
1495  UT_Vector3D myInvalidPrimClr;
1496  bool myUseInvalidGrp;
1497  UT_StringHolder myInvalidPrimGrp;
1498 
1499 };
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
void loadFromOpSubclass(const LoadParms &loadparms) override
const UT_StringHolder & getTargetSizeAttrib() const
static void saveData(std::ostream &os, UT_Vector3D v)
bool opUseTargetSizeAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
int int32
Definition: SYS_Types.h:39
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:347
static void saveData(std::ostream &os, UT_Matrix4D v)
fpreal64 opUniformMaxSize(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getInvalidPrimGrp() const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
bool opUseIsectGrp(const SOP_NodeVerb::CookParms &cookparms) const
int64 opMaxIter(const SOP_NodeVerb::CookParms &cookparms) const
T clampMaxValue(fpreal maxvalue, const T &src) const
Definition: OP_NodeParms.h:315
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
static void saveData(std::ostream &os, bool v)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
exint bread(int32 *buffer, exint asize=1)
GLboolean * data
Definition: glcorearb.h:131
static void saveData(std::ostream &os, UT_Matrix2D v)
GT_API const UT_StringHolder time
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector4.h:493
const GLdouble * v
Definition: glcorearb.h:837
fpreal getTime() const
Definition: OP_Context.h:62
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
bool opOneFacePerTet(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
bool opUseIsectColor(const SOP_NodeVerb::CookParms &cookparms) const
int64 opMaxAttempts(const SOP_NodeVerb::CookParms &cookparms) const
const OP_Context & context() const
Definition: OP_NodeParms.h:97
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
bool opOptVtxSmooth(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
Mode opMode(const SOP_NodeVerb::CookParms &cookparms) const
GLdouble s
Definition: glad.h:3009
void setTargetSizeAttrib(const UT_StringHolder &val)
An output stream object that owns its own string buffer storage.
fpreal64 opPrecisionTol(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3D &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
**But if you need a result
Definition: thread.h:613
static void saveData(std::ostream &os, UT_Vector4D v)
T clampMinValue(fpreal minvalue, const T &src) const
Definition: OP_NodeParms.h:308
UT_StringHolder opIsectPolyGrp(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opIsectPolyClr(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix4D &v)
fpreal64 opDihedralAngleTol(const SOP_NodeVerb::CookParms &cookparms) const
exint nodeIdx() const
Definition: OP_NodeParms.h:95
fpreal64 opRadEdgeTol(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
bool opUseInvalidGrp(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, int64 v)
bool opUseMaxSizeAttrib(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opPieceAttrib(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector4.h:491
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
void setMaxSizeAttrib(const UT_StringHolder &val)
const UT_StringHolder & getIsectPolyGrp() const
UT_Vector3D opInvalidPrimClr(const SOP_NodeVerb::CookParms &cookparms) const
int64 opRandomSeed(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getPieceAttrib() const
void setGroup(const UT_StringHolder &val)
UT_StringHolder opMaxSizeAttrib(const SOP_NodeVerb::CookParms &cookparms) const
ParmType getNestParmType(TempIndex fieldnum) const override
double fpreal64
Definition: SYS_Types.h:201
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector2.h:423
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
bool opUseInvalidColor(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
bool opUseQuality(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
static void loadData(UT_IStream &is, int64 &v)
void save(std::ostream &os) const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
exint length() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
fpreal64 opMinDihedralAngle(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:36
exint getNestNumParms(TempIndex idx) const override
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector4.h:495
UT_StringHolder opTargetSizeAttrib(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getMaxSizeAttrib() const
const OP_GraphProxy * graph() const
Definition: OP_NodeParms.h:94
bool opUseUniformMaxSize(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const SOP_Tetrahedralize_2_0Parms &src) const
void setPieceAttrib(const UT_StringHolder &val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
static void loadData(UT_IStream &is, UT_Vector3I &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
long long int64
Definition: SYS_Types.h:116
const char * getNestParmName(TempIndex fieldnum) const override
UT_Vector3T< fpreal64 > UT_Vector3D
bool opOptEdgeFace(const SOP_NodeVerb::CookParms &cookparms) const
Output opOutput(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, fpreal64 v)
UT_StringHolder opInvalidPrimGrp(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
bool opKeepPrims(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
static void saveData(std::ostream &os, UT_Vector2D v)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:296
bool operator!=(const SOP_Tetrahedralize_2_0Parms &src) const
GT_API const UT_StringHolder version
bool opRemove(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, fpreal64 &v)
bool opOptVtxMod(const SOP_NodeVerb::CookParms &cookparms) const
void setIsectPolyGrp(const UT_StringHolder &val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void coerceValue(T &result, const S &src) const
Definition: OP_NodeParms.h:301
static void saveData(std::ostream &os, UT_StringHolder s)
void setInvalidPrimGrp(const UT_StringHolder &val)
fpreal64 fpreal
Definition: SYS_Types.h:277
DEP_MicroNode * depnode() const
Definition: OP_NodeParms.h:99
Utility class for containing a color ramp.
Definition: UT_Ramp.h:88
static void loadData(UT_IStream &is, UT_Vector4I &v)
Failures opFailures(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2D &v)
constexpr SYS_FORCE_INLINE T & w() noexcept
Definition: UT_Vector4.h:497
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
static void loadData(UT_IStream &is, UT_Vector4D &v)
GLuint GLfloat * val
Definition: glcorearb.h:1608
bool opPropNormal(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
#define SOP_API
Definition: SOP_API.h:10
int64 opMaxSteiner(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:361
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
Batch opBatch(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseMaxIter(const SOP_NodeVerb::CookParms &cookparms) const
bool opInternAttrib(const SOP_NodeVerb::CookParms &cookparms) const
const char * findChar(int c) const
Definition: UT_String.h:1385
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
Definition: core.h:1131
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
GLboolean r
Definition: glcorearb.h:1222
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
bool opUseMaxSteiner(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getGroup() const
int64 opOptIterations(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, bool &v)
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector3.h:665
static void loadData(UT_IStream &is, UT_StringHolder &v)
type
Definition: core.h:1059
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:89
void copyFrom(const OP_NodeParms *src) override
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector2.h:425
static void loadData(UT_IStream &is, UT_Matrix3D &v)
SYS_FORCE_INLINE bool isstring() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
bool opNoBoundMod(const SOP_NodeVerb::CookParms &cookparms) const
OP_NodeParms & operator=(const OP_NodeParms &)=default
bool isParmColorRamp(exint idx) const override
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
static void saveData(std::ostream &os, UT_Matrix3D v)
GLenum src
Definition: glcorearb.h:1793
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector3.h:663