HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_QuadRemesh.proto.h
Go to the documentation of this file.
1 /* Automagically Generated by generate_proto.py
2  * Do not Edit
3  */
4 #pragma once
5 
6 #include <SOP/SOP_API.h>
7 #include <SOP/SOP_NodeVerb.h>
8 #include <OP/OP_GraphProxy.h>
9 
10 #include <OP/OP_Utils.h>
11 #include <PRM/PRM_Parm.h>
12 #include <UT/UT_IStream.h>
13 #include <UT/UT_NTStreamUtil.h>
14 #include <UT/UT_Ramp.h>
15 #include <UT/UT_SharedPtr.h>
16 #include <UT/UT_StringHolder.h>
17 #include <UT/UT_StringStream.h>
18 #include <UT/UT_VectorTypes.h>
19 #include <UT/UT_EnvControl.h>
20 #include <SYS/SYS_Types.h>
21 
22 class DEP_MicroNode;
23 namespace SOP_QuadRemeshEnums
24 {
25  enum class Output
26  {
27  EXTRACTED_MESH = 0,
29  };
30 
32  getToken(Output enum_value)
33  {
34  using namespace UT::Literal;
35  switch (enum_value) {
36  case Output::EXTRACTED_MESH: return "extracted_mesh"_sh;
37  case Output::GLOBAL_TEXTURE: return "global_texture"_sh;
38  default: UT_ASSERT(false); return ""_sh;
39  }
40  }
41 
42  enum class ResolutionMode
43  {
44  QUAD_COUNT = 0,
45  QUAD_AREA,
46  TOLERANCE,
49  };
50 
52  getToken(ResolutionMode enum_value)
53  {
54  using namespace UT::Literal;
55  switch (enum_value) {
56  case ResolutionMode::QUAD_COUNT: return "quad_count"_sh;
57  case ResolutionMode::QUAD_AREA: return "quad_area"_sh;
58  case ResolutionMode::TOLERANCE: return "tolerance"_sh;
59  case ResolutionMode::RELATIVE_SCALE: return "relative_scale"_sh;
60  case ResolutionMode::ABSOLUTE_SCALE: return "absolute_scale"_sh;
61  default: UT_ASSERT(false); return ""_sh;
62  }
63  }
64 
65  enum class ResolutionSource
66  {
67  AUTO = 0,
69  };
70 
73  {
74  using namespace UT::Literal;
75  switch (enum_value) {
76  case ResolutionSource::AUTO: return "auto"_sh;
77  case ResolutionSource::TRIANGLE_AREA: return "triangle_area"_sh;
78  default: UT_ASSERT(false); return ""_sh;
79  }
80  }
81 
82  enum class XDirection
83  {
84  POSITIVE = 0,
85  NEGATIVE
86  };
87 
89  getToken(XDirection enum_value)
90  {
91  using namespace UT::Literal;
92  switch (enum_value) {
93  case XDirection::POSITIVE: return "positive"_sh;
94  case XDirection::NEGATIVE: return "negative"_sh;
95  default: UT_ASSERT(false); return ""_sh;
96  }
97  }
98 
99  enum class YDirection
100  {
101  POSITIVE = 0,
102  NEGATIVE
103  };
104 
106  getToken(YDirection enum_value)
107  {
108  using namespace UT::Literal;
109  switch (enum_value) {
110  case YDirection::POSITIVE: return "positive"_sh;
111  case YDirection::NEGATIVE: return "negative"_sh;
112  default: UT_ASSERT(false); return ""_sh;
113  }
114  }
115 
116  enum class ZDirection
117  {
118  POSITIVE = 0,
119  NEGATIVE
120  };
121 
123  getToken(ZDirection enum_value)
124  {
125  using namespace UT::Literal;
126  switch (enum_value) {
127  case ZDirection::POSITIVE: return "positive"_sh;
128  case ZDirection::NEGATIVE: return "negative"_sh;
129  default: UT_ASSERT(false); return ""_sh;
130  }
131  }
132 
133  enum class Field
134  {
135  FACE = 0,
136  EDGE
137  };
138 
140  getToken(Field enum_value)
141  {
142  using namespace UT::Literal;
143  switch (enum_value) {
144  case Field::FACE: return "face"_sh;
145  case Field::EDGE: return "edge"_sh;
146  default: UT_ASSERT(false); return ""_sh;
147  }
148  }
149 
150  enum class BoundaryMode
151  {
152  ADD = 0,
153  OVER
154  };
155 
157  getToken(BoundaryMode enum_value)
158  {
159  using namespace UT::Literal;
160  switch (enum_value) {
161  case BoundaryMode::ADD: return "add"_sh;
162  case BoundaryMode::OVER: return "over"_sh;
163  default: UT_ASSERT(false); return ""_sh;
164  }
165  }
166 
167  enum class GuideMode
168  {
169  ADD = 0,
170  OVER
171  };
172 
174  getToken(GuideMode enum_value)
175  {
176  using namespace UT::Literal;
177  switch (enum_value) {
178  case GuideMode::ADD: return "add"_sh;
179  case GuideMode::OVER: return "over"_sh;
180  default: UT_ASSERT(false); return ""_sh;
181  }
182  }
183 
184 }
185 
186 
188 {
189 public:
190  static int version() { return 1; }
191 
193  {
194  myGroup = ""_UTsh;
195  myDecimation = true;
196  myDecimationLevel = 2;
197  myOutput = 0;
198  myResolutionMode = 0;
199  myTargetQuadCount = 10000;
200  myTargetQuadArea = .1;
201  myTargetTolerance = .1;
202  myResolutionScale = 0;
203  myResolutionSource = 0;
204  myTriangleArea = .125;
205  mySymmetryCenter = UT_Vector3D(0,0,0);
206  myXAxis = false;
207  myXDirection = 0;
208  myYAxis = false;
209  myYDirection = 0;
210  myZAxis = false;
211  myZDirection = 0;
212  myMirrorOutput = true;
213  myEnableAdaptivity = true;
214  myAdaptivityWeight = 0.5;
215  myAdaptivityMaskAttrib = ""_UTsh;
216  myAdaptivitySizing = false;
217  myAdaptivitySizingAttrib = ""_UTsh;
218  myFeatureBoundaries = true;
219  myField = 0;
220  myGlobalWeight = 0.1;
221  myGlobalMask = ""_UTsh;
222  myCurvature = true;
223  myLocalCurvatureWeight = 1;
224  myCurvatureMaskAttrib = ""_UTsh;
225  myCurvatureRotation = 0;
226  myBoundary = true;
227  myBoundaryMode = 0;
228  myLocalBoundaryWeight = 1;
229  myBoundaryMaskAttrib = ""_UTsh;
230  myBoundaryRotation = 0;
231  myGuide = false;
232  myGuideMaskAttrib = ""_UTsh;
233  myGuideAttrib = ""_UTsh;
234  myAdaptivitySizingWeight = 1;
235  myGuideMode = 0;
236  myLocalGuideWeight = 1;
237 
238  }
239 
240  explicit SOP_QuadRemeshParms(const SOP_QuadRemeshParms &) = default;
242  SOP_QuadRemeshParms(SOP_QuadRemeshParms &&) noexcept = default;
243  SOP_QuadRemeshParms &operator=(SOP_QuadRemeshParms &&) noexcept = default;
244 
245  ~SOP_QuadRemeshParms() override {}
246 
247  bool operator==(const SOP_QuadRemeshParms &src) const
248  {
249  if (myGroup != src.myGroup) return false;
250  if (myDecimation != src.myDecimation) return false;
251  if (myDecimationLevel != src.myDecimationLevel) return false;
252  if (myOutput != src.myOutput) return false;
253  if (myResolutionMode != src.myResolutionMode) return false;
254  if (myTargetQuadCount != src.myTargetQuadCount) return false;
255  if (myTargetQuadArea != src.myTargetQuadArea) return false;
256  if (myTargetTolerance != src.myTargetTolerance) return false;
257  if (myResolutionScale != src.myResolutionScale) return false;
258  if (myResolutionSource != src.myResolutionSource) return false;
259  if (myTriangleArea != src.myTriangleArea) return false;
260  if (mySymmetryCenter != src.mySymmetryCenter) return false;
261  if (myXAxis != src.myXAxis) return false;
262  if (myXDirection != src.myXDirection) return false;
263  if (myYAxis != src.myYAxis) return false;
264  if (myYDirection != src.myYDirection) return false;
265  if (myZAxis != src.myZAxis) return false;
266  if (myZDirection != src.myZDirection) return false;
267  if (myMirrorOutput != src.myMirrorOutput) return false;
268  if (myEnableAdaptivity != src.myEnableAdaptivity) return false;
269  if (myAdaptivityWeight != src.myAdaptivityWeight) return false;
270  if (myAdaptivityMaskAttrib != src.myAdaptivityMaskAttrib) return false;
271  if (myAdaptivitySizing != src.myAdaptivitySizing) return false;
272  if (myAdaptivitySizingAttrib != src.myAdaptivitySizingAttrib) return false;
273  if (myFeatureBoundaries != src.myFeatureBoundaries) return false;
274  if (myField != src.myField) return false;
275  if (myGlobalWeight != src.myGlobalWeight) return false;
276  if (myGlobalMask != src.myGlobalMask) return false;
277  if (myCurvature != src.myCurvature) return false;
278  if (myLocalCurvatureWeight != src.myLocalCurvatureWeight) return false;
279  if (myCurvatureMaskAttrib != src.myCurvatureMaskAttrib) return false;
280  if (myCurvatureRotation != src.myCurvatureRotation) return false;
281  if (myBoundary != src.myBoundary) return false;
282  if (myBoundaryMode != src.myBoundaryMode) return false;
283  if (myLocalBoundaryWeight != src.myLocalBoundaryWeight) return false;
284  if (myBoundaryMaskAttrib != src.myBoundaryMaskAttrib) return false;
285  if (myBoundaryRotation != src.myBoundaryRotation) return false;
286  if (myGuide != src.myGuide) return false;
287  if (myGuideMaskAttrib != src.myGuideMaskAttrib) return false;
288  if (myGuideAttrib != src.myGuideAttrib) return false;
289  if (myAdaptivitySizingWeight != src.myAdaptivitySizingWeight) return false;
290  if (myGuideMode != src.myGuideMode) return false;
291  if (myLocalGuideWeight != src.myLocalGuideWeight) return false;
292 
293 
294  if (baseGetSignature() != src.baseGetSignature()) return false;
295 
296  return true;
297  }
298  bool operator!=(const SOP_QuadRemeshParms &src) const
299  {
300  return !operator==(src);
301  }
311 
312 
313 
314  void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
315  {
316  myGroup = ""_UTsh;
317  if (true)
318  graph->evalOpParm(myGroup, nodeidx, "group", time, graph->isDirect()?nullptr:depnode);
319  myDecimation = true;
320  if (true)
321  graph->evalOpParm(myDecimation, nodeidx, "decimation", time, graph->isDirect()?nullptr:depnode);
322  myDecimationLevel = 2;
323  if (true && ( (true&&!(((getDecimation()==0)))) ) )
324  graph->evalOpParm(myDecimationLevel, nodeidx, "decimationlevel", time, graph->isDirect()?nullptr:depnode);
325  myOutput = 0;
326  if (true)
327  graph->evalOpParm(myOutput, nodeidx, "output", time, graph->isDirect()?nullptr:depnode);
328  myResolutionMode = 0;
329  if (true)
330  graph->evalOpParm(myResolutionMode, nodeidx, "resolution", time, graph->isDirect()?nullptr:depnode);
331  myTargetQuadCount = 10000;
332  if (true && ( (true&&!(((int64(getResolutionMode())!=0)))) ) )
333  graph->evalOpParm(myTargetQuadCount, nodeidx, "targetquadcount", time, graph->isDirect()?nullptr:depnode);
334  myTargetQuadArea = .1;
335  if (true && ( (true&&!(((int64(getResolutionMode())!=1)))) ) )
336  graph->evalOpParm(myTargetQuadArea, nodeidx, "targetquadarea", time, graph->isDirect()?nullptr:depnode);
337  myTargetTolerance = .1;
338  if (true && ( (true&&!(((int64(getResolutionMode())!=2)))) ) )
339  graph->evalOpParm(myTargetTolerance, nodeidx, "targettolerance", time, graph->isDirect()?nullptr:depnode);
340  myResolutionScale = 0;
341  if (true && ( (true&&!(((int64(getResolutionMode())!=4)&&(int64(getResolutionMode())!=3)))) ) )
342  graph->evalOpParm(myResolutionScale, nodeidx, "resolutionscale", time, graph->isDirect()?nullptr:depnode);
343  myResolutionSource = 0;
344  if (true && ( (true&&!(((int64(getResolutionMode())!=4)))) ) )
345  graph->evalOpParm(myResolutionSource, nodeidx, "resolutionsource", time, graph->isDirect()?nullptr:depnode);
346  myTriangleArea = .125;
347  if (true && ( (true&&!(((int64(getResolutionMode())!=4))||((int64(getResolutionSource())!=1)))) ) )
348  graph->evalOpParm(myTriangleArea, nodeidx, "trianglearea", time, graph->isDirect()?nullptr:depnode);
349  mySymmetryCenter = UT_Vector3D(0,0,0);
350  if (true)
351  graph->evalOpParm(mySymmetryCenter, nodeidx, "symmetrycenter", time, graph->isDirect()?nullptr:depnode);
352  myXAxis = false;
353  if (true)
354  graph->evalOpParm(myXAxis, nodeidx, "xaxis", time, graph->isDirect()?nullptr:depnode);
355  myXDirection = 0;
356  if (true)
357  graph->evalOpParm(myXDirection, nodeidx, "xdirection", time, graph->isDirect()?nullptr:depnode);
358  myYAxis = false;
359  if (true)
360  graph->evalOpParm(myYAxis, nodeidx, "yaxis", time, graph->isDirect()?nullptr:depnode);
361  myYDirection = 0;
362  if (true)
363  graph->evalOpParm(myYDirection, nodeidx, "ydirection", time, graph->isDirect()?nullptr:depnode);
364  myZAxis = false;
365  if (true)
366  graph->evalOpParm(myZAxis, nodeidx, "zaxis", time, graph->isDirect()?nullptr:depnode);
367  myZDirection = 0;
368  if (true)
369  graph->evalOpParm(myZDirection, nodeidx, "zdirection", time, graph->isDirect()?nullptr:depnode);
370  myMirrorOutput = true;
371  if (true)
372  graph->evalOpParm(myMirrorOutput, nodeidx, "mirroroutput", time, graph->isDirect()?nullptr:depnode);
373  myEnableAdaptivity = true;
374  if (true)
375  graph->evalOpParm(myEnableAdaptivity, nodeidx, "enableadaptivity", time, graph->isDirect()?nullptr:depnode);
376  myAdaptivityWeight = 0.5;
377  if (true && ( (true&&!(((getEnableAdaptivity()==0)))) ) )
378  graph->evalOpParm(myAdaptivityWeight, nodeidx, "adaptivityweight", time, graph->isDirect()?nullptr:depnode);
379  myAdaptivityMaskAttrib = ""_UTsh;
380  if (true && ( (true&&!(((getEnableAdaptivity()==0)))) ) )
381  graph->evalOpParm(myAdaptivityMaskAttrib, nodeidx, "adaptivitymaskattrib", time, graph->isDirect()?nullptr:depnode);
382  myAdaptivitySizing = false;
383  if (true && ( (true&&!(((getEnableAdaptivity()==0)))) ) )
384  graph->evalOpParm(myAdaptivitySizing, nodeidx, "adaptivitysizing", time, graph->isDirect()?nullptr:depnode);
385  myAdaptivitySizingAttrib = ""_UTsh;
386  if (true && ( (true&&!(((getAdaptivitySizing()==0))||((getEnableAdaptivity()==0)))) ) )
387  graph->evalOpParm(myAdaptivitySizingAttrib, nodeidx, "adaptivitysizingattrib", time, graph->isDirect()?nullptr:depnode);
388  myFeatureBoundaries = true;
389  if (true)
390  graph->evalOpParm(myFeatureBoundaries, nodeidx, "featureboundaries", time, graph->isDirect()?nullptr:depnode);
391  myField = 0;
392  if (true)
393  graph->evalOpParm(myField, nodeidx, "field", time, graph->isDirect()?nullptr:depnode);
394  myGlobalWeight = 0.1;
395  if (true)
396  graph->evalOpParm(myGlobalWeight, nodeidx, "globalweight", time, graph->isDirect()?nullptr:depnode);
397  myGlobalMask = ""_UTsh;
398  if (true && ( (true&&!(((int64(getField())==1)))) ) )
399  graph->evalOpParm(myGlobalMask, nodeidx, "globalmask", time, graph->isDirect()?nullptr:depnode);
400  myCurvature = true;
401  if (true && ( (true&&!(((int64(getField())==1)))) ) )
402  graph->evalOpParm(myCurvature, nodeidx, "curvature", time, graph->isDirect()?nullptr:depnode);
403  myLocalCurvatureWeight = 1;
404  if (true && ( (true&&!(((int64(getField())==1))||((getCurvature()==0)))) ) )
405  graph->evalOpParm(myLocalCurvatureWeight, nodeidx, "localcurvatureweight", time, graph->isDirect()?nullptr:depnode);
406  myCurvatureMaskAttrib = ""_UTsh;
407  if (true && ( (true&&!(((int64(getField())==1))||((getCurvature()==0)))) ) )
408  graph->evalOpParm(myCurvatureMaskAttrib, nodeidx, "curvaturemaskattrib", time, graph->isDirect()?nullptr:depnode);
409  myCurvatureRotation = 0;
410  if (true && ( (true&&!(((int64(getField())==1))||((getCurvature()==0)))) ) )
411  graph->evalOpParm(myCurvatureRotation, nodeidx, "curvaturerotation", time, graph->isDirect()?nullptr:depnode);
412  myBoundary = true;
413  if (true && ( (true&&!(((int64(getField())==1)))) ) )
414  graph->evalOpParm(myBoundary, nodeidx, "boundary", time, graph->isDirect()?nullptr:depnode);
415  myBoundaryMode = 0;
416  if (true && ( (true&&!(((int64(getField())==1))||((getBoundary()==0)))) ) )
417  graph->evalOpParm(myBoundaryMode, nodeidx, "boundarymode", time, graph->isDirect()?nullptr:depnode);
418  myLocalBoundaryWeight = 1;
419  if (true && ( (true&&!(((int64(getField())==1))||((getBoundary()==0)))) ) )
420  graph->evalOpParm(myLocalBoundaryWeight, nodeidx, "localboundaryweight", time, graph->isDirect()?nullptr:depnode);
421  myBoundaryMaskAttrib = ""_UTsh;
422  if (true && ( (true&&!(((int64(getField())==1))||((getBoundary()==0)))) ) )
423  graph->evalOpParm(myBoundaryMaskAttrib, nodeidx, "boundarymaskattrib", time, graph->isDirect()?nullptr:depnode);
424  myBoundaryRotation = 0;
425  if (true && ( (true&&!(((int64(getField())==1))||((getBoundary()==0)))) ) )
426  graph->evalOpParm(myBoundaryRotation, nodeidx, "boundaryrotation", time, graph->isDirect()?nullptr:depnode);
427  myGuide = false;
428  if (true && ( (true&&!(((int64(getField())==1)))) ) )
429  graph->evalOpParm(myGuide, nodeidx, "guide", time, graph->isDirect()?nullptr:depnode);
430  myGuideMaskAttrib = ""_UTsh;
431  if (true && ( (true&&!(((int64(getField())==1))||((getGuide()==0)))) ) )
432  graph->evalOpParm(myGuideMaskAttrib, nodeidx, "guidemaskattrib", time, graph->isDirect()?nullptr:depnode);
433  myGuideAttrib = ""_UTsh;
434  if (true && ( (true&&!(((int64(getField())==1))||((getGuide()==0)))) ) )
435  graph->evalOpParm(myGuideAttrib, nodeidx, "guideattrib", time, graph->isDirect()?nullptr:depnode);
436  myAdaptivitySizingWeight = 1;
437  if (true && ( (true&&!(((getAdaptivitySizing()==0))||((getEnableAdaptivity()==0))||((getAdaptivitySizingAttrib()=="")))) ) )
438  graph->evalOpParm(myAdaptivitySizingWeight, nodeidx, "adaptivitysizingweight", time, graph->isDirect()?nullptr:depnode);
439  myGuideMode = 0;
440  if (true && ( (true&&!(((int64(getField())==1))||((getGuide()==0))||((getGuideAttrib()=="")))) ) )
441  graph->evalOpParm(myGuideMode, nodeidx, "guidemode", time, graph->isDirect()?nullptr:depnode);
442  myLocalGuideWeight = 1;
443  if (true && ( (true&&!(((int64(getField())==1))||((getGuide()==0))||((getGuideAttrib()=="")))) ) )
444  graph->evalOpParm(myLocalGuideWeight, nodeidx, "localguideweight", time, graph->isDirect()?nullptr:depnode);
445 
446  }
447 
448 
449  void loadFromOpSubclass(const LoadParms &loadparms) override
450  {
451  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
452  }
453 
454 
455  void copyFrom(const OP_NodeParms *src) override
456  {
457  *this = *((const SOP_QuadRemeshParms *)src);
458  }
459 
460  template <typename T>
461  void
462  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
463  {
464  if (idx.size() < 1)
465  return;
466  UT_ASSERT(idx.size() == instance.size()+1);
467  if (idx.size() != instance.size()+1)
468  return;
469  switch (idx[0])
470  {
471  case 0:
472  coerceValue(value, myGroup);
473  break;
474  case 1:
475  coerceValue(value, myDecimation);
476  break;
477  case 2:
478  coerceValue(value, myDecimationLevel);
479  break;
480  case 3:
481  coerceValue(value, myOutput);
482  break;
483  case 4:
484  coerceValue(value, myResolutionMode);
485  break;
486  case 5:
487  coerceValue(value, myTargetQuadCount);
488  break;
489  case 6:
490  coerceValue(value, myTargetQuadArea);
491  break;
492  case 7:
493  coerceValue(value, myTargetTolerance);
494  break;
495  case 8:
496  coerceValue(value, myResolutionScale);
497  break;
498  case 9:
499  coerceValue(value, myResolutionSource);
500  break;
501  case 10:
502  coerceValue(value, myTriangleArea);
503  break;
504  case 11:
505  coerceValue(value, mySymmetryCenter);
506  break;
507  case 12:
508  coerceValue(value, myXAxis);
509  break;
510  case 13:
511  coerceValue(value, myXDirection);
512  break;
513  case 14:
514  coerceValue(value, myYAxis);
515  break;
516  case 15:
517  coerceValue(value, myYDirection);
518  break;
519  case 16:
520  coerceValue(value, myZAxis);
521  break;
522  case 17:
523  coerceValue(value, myZDirection);
524  break;
525  case 18:
526  coerceValue(value, myMirrorOutput);
527  break;
528  case 19:
529  coerceValue(value, myEnableAdaptivity);
530  break;
531  case 20:
532  coerceValue(value, myAdaptivityWeight);
533  break;
534  case 21:
535  coerceValue(value, myAdaptivityMaskAttrib);
536  break;
537  case 22:
538  coerceValue(value, myAdaptivitySizing);
539  break;
540  case 23:
541  coerceValue(value, myAdaptivitySizingAttrib);
542  break;
543  case 24:
544  coerceValue(value, myFeatureBoundaries);
545  break;
546  case 25:
547  coerceValue(value, myField);
548  break;
549  case 26:
550  coerceValue(value, myGlobalWeight);
551  break;
552  case 27:
553  coerceValue(value, myGlobalMask);
554  break;
555  case 28:
556  coerceValue(value, myCurvature);
557  break;
558  case 29:
559  coerceValue(value, myLocalCurvatureWeight);
560  break;
561  case 30:
562  coerceValue(value, myCurvatureMaskAttrib);
563  break;
564  case 31:
565  coerceValue(value, myCurvatureRotation);
566  break;
567  case 32:
568  coerceValue(value, myBoundary);
569  break;
570  case 33:
571  coerceValue(value, myBoundaryMode);
572  break;
573  case 34:
574  coerceValue(value, myLocalBoundaryWeight);
575  break;
576  case 35:
577  coerceValue(value, myBoundaryMaskAttrib);
578  break;
579  case 36:
580  coerceValue(value, myBoundaryRotation);
581  break;
582  case 37:
583  coerceValue(value, myGuide);
584  break;
585  case 38:
586  coerceValue(value, myGuideMaskAttrib);
587  break;
588  case 39:
589  coerceValue(value, myGuideAttrib);
590  break;
591  case 40:
592  coerceValue(value, myAdaptivitySizingWeight);
593  break;
594  case 41:
595  coerceValue(value, myGuideMode);
596  break;
597  case 42:
598  coerceValue(value, myLocalGuideWeight);
599  break;
600 
601  }
602  }
603 
604  bool isParmColorRamp(exint idx) const override
605  {
606  switch (idx)
607  {
608 
609  }
610  return false;
611  }
612 
613  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
614  { doGetParmValue(idx, instance, value); }
615  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
616  { doGetParmValue(idx, instance, value); }
617  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
618  { doGetParmValue(idx, instance, value); }
619  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
620  { doGetParmValue(idx, instance, value); }
621  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
622  { doGetParmValue(idx, instance, value); }
623  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
624  { doGetParmValue(idx, instance, value); }
625  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
626  { doGetParmValue(idx, instance, value); }
627  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
628  { doGetParmValue(idx, instance, value); }
629  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
630  { doGetParmValue(idx, instance, value); }
631  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
632  { doGetParmValue(idx, instance, value); }
633  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
634  { doGetParmValue(idx, instance, value); }
635 
636  template <typename T>
637  void
638  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
639  {
640  if (idx.size() < 1)
641  return;
642  UT_ASSERT(idx.size() == instance.size()+1);
643  if (idx.size() != instance.size()+1)
644  return;
645  switch (idx[0])
646  {
647  case 0:
648  coerceValue(myGroup, ( ( value ) ));
649  break;
650  case 1:
651  coerceValue(myDecimation, ( ( value ) ));
652  break;
653  case 2:
654  coerceValue(myDecimationLevel, clampMinValue(1, clampMaxValue(12, value ) ));
655  break;
656  case 3:
657  coerceValue(myOutput, clampMinValue(0, clampMaxValue(1, value ) ));
658  break;
659  case 4:
660  coerceValue(myResolutionMode, clampMinValue(0, clampMaxValue(4, value ) ));
661  break;
662  case 5:
663  coerceValue(myTargetQuadCount, clampMinValue(1, ( value ) ));
664  break;
665  case 6:
666  coerceValue(myTargetQuadArea, clampMinValue(0, ( value ) ));
667  break;
668  case 7:
669  coerceValue(myTargetTolerance, clampMinValue(0, ( value ) ));
670  break;
671  case 8:
672  coerceValue(myResolutionScale, ( ( value ) ));
673  break;
674  case 9:
675  coerceValue(myResolutionSource, clampMinValue(0, clampMaxValue(1, value ) ));
676  break;
677  case 10:
678  coerceValue(myTriangleArea, ( ( value ) ));
679  break;
680  case 11:
681  coerceValue(mySymmetryCenter, ( ( value ) ));
682  break;
683  case 12:
684  coerceValue(myXAxis, ( ( value ) ));
685  break;
686  case 13:
687  coerceValue(myXDirection, clampMinValue(0, clampMaxValue(1, value ) ));
688  break;
689  case 14:
690  coerceValue(myYAxis, ( ( value ) ));
691  break;
692  case 15:
693  coerceValue(myYDirection, clampMinValue(0, clampMaxValue(1, value ) ));
694  break;
695  case 16:
696  coerceValue(myZAxis, ( ( value ) ));
697  break;
698  case 17:
699  coerceValue(myZDirection, clampMinValue(0, clampMaxValue(1, value ) ));
700  break;
701  case 18:
702  coerceValue(myMirrorOutput, ( ( value ) ));
703  break;
704  case 19:
705  coerceValue(myEnableAdaptivity, ( ( value ) ));
706  break;
707  case 20:
708  coerceValue(myAdaptivityWeight, clampMinValue(0, ( value ) ));
709  break;
710  case 21:
711  coerceValue(myAdaptivityMaskAttrib, ( ( value ) ));
712  break;
713  case 22:
714  coerceValue(myAdaptivitySizing, ( ( value ) ));
715  break;
716  case 23:
717  coerceValue(myAdaptivitySizingAttrib, ( ( value ) ));
718  break;
719  case 24:
720  coerceValue(myFeatureBoundaries, ( ( value ) ));
721  break;
722  case 25:
723  coerceValue(myField, clampMinValue(0, clampMaxValue(1, value ) ));
724  break;
725  case 26:
726  coerceValue(myGlobalWeight, clampMinValue(0, ( value ) ));
727  break;
728  case 27:
729  coerceValue(myGlobalMask, ( ( value ) ));
730  break;
731  case 28:
732  coerceValue(myCurvature, ( ( value ) ));
733  break;
734  case 29:
735  coerceValue(myLocalCurvatureWeight, clampMinValue(0, ( value ) ));
736  break;
737  case 30:
738  coerceValue(myCurvatureMaskAttrib, ( ( value ) ));
739  break;
740  case 31:
741  coerceValue(myCurvatureRotation, ( ( value ) ));
742  break;
743  case 32:
744  coerceValue(myBoundary, ( ( value ) ));
745  break;
746  case 33:
747  coerceValue(myBoundaryMode, clampMinValue(0, clampMaxValue(1, value ) ));
748  break;
749  case 34:
750  coerceValue(myLocalBoundaryWeight, clampMinValue(0, ( value ) ));
751  break;
752  case 35:
753  coerceValue(myBoundaryMaskAttrib, ( ( value ) ));
754  break;
755  case 36:
756  coerceValue(myBoundaryRotation, ( ( value ) ));
757  break;
758  case 37:
759  coerceValue(myGuide, ( ( value ) ));
760  break;
761  case 38:
762  coerceValue(myGuideMaskAttrib, ( ( value ) ));
763  break;
764  case 39:
765  coerceValue(myGuideAttrib, ( ( value ) ));
766  break;
767  case 40:
768  coerceValue(myAdaptivitySizingWeight, clampMinValue(0, ( value ) ));
769  break;
770  case 41:
771  coerceValue(myGuideMode, clampMinValue(0, clampMaxValue(1, value ) ));
772  break;
773  case 42:
774  coerceValue(myLocalGuideWeight, clampMinValue(0, ( value ) ));
775  break;
776 
777  }
778  }
779 
780  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
781  { doSetParmValue(idx, instance, value); }
782  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
783  { doSetParmValue(idx, instance, value); }
784  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
785  { doSetParmValue(idx, instance, value); }
786  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
787  { doSetParmValue(idx, instance, value); }
788  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
789  { doSetParmValue(idx, instance, value); }
790  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
791  { doSetParmValue(idx, instance, value); }
792  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
793  { doSetParmValue(idx, instance, value); }
794  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
795  { doSetParmValue(idx, instance, value); }
796  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
797  { doSetParmValue(idx, instance, value); }
798  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
799  { doSetParmValue(idx, instance, value); }
800  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
801  { doSetParmValue(idx, instance, value); }
802 
803  exint getNestNumParms(TempIndex idx) const override
804  {
805  if (idx.size() == 0)
806  return 43;
807  switch (idx[0])
808  {
809 
810  }
811  // Invalid
812  return 0;
813  }
814 
815  const char *getNestParmName(TempIndex fieldnum) const override
816  {
817  if (fieldnum.size() < 1)
818  return 0;
819  switch (fieldnum[0])
820  {
821  case 0:
822  return "group";
823  case 1:
824  return "decimation";
825  case 2:
826  return "decimationlevel";
827  case 3:
828  return "output";
829  case 4:
830  return "resolution";
831  case 5:
832  return "targetquadcount";
833  case 6:
834  return "targetquadarea";
835  case 7:
836  return "targettolerance";
837  case 8:
838  return "resolutionscale";
839  case 9:
840  return "resolutionsource";
841  case 10:
842  return "trianglearea";
843  case 11:
844  return "symmetrycenter";
845  case 12:
846  return "xaxis";
847  case 13:
848  return "xdirection";
849  case 14:
850  return "yaxis";
851  case 15:
852  return "ydirection";
853  case 16:
854  return "zaxis";
855  case 17:
856  return "zdirection";
857  case 18:
858  return "mirroroutput";
859  case 19:
860  return "enableadaptivity";
861  case 20:
862  return "adaptivityweight";
863  case 21:
864  return "adaptivitymaskattrib";
865  case 22:
866  return "adaptivitysizing";
867  case 23:
868  return "adaptivitysizingattrib";
869  case 24:
870  return "featureboundaries";
871  case 25:
872  return "field";
873  case 26:
874  return "globalweight";
875  case 27:
876  return "globalmask";
877  case 28:
878  return "curvature";
879  case 29:
880  return "localcurvatureweight";
881  case 30:
882  return "curvaturemaskattrib";
883  case 31:
884  return "curvaturerotation";
885  case 32:
886  return "boundary";
887  case 33:
888  return "boundarymode";
889  case 34:
890  return "localboundaryweight";
891  case 35:
892  return "boundarymaskattrib";
893  case 36:
894  return "boundaryrotation";
895  case 37:
896  return "guide";
897  case 38:
898  return "guidemaskattrib";
899  case 39:
900  return "guideattrib";
901  case 40:
902  return "adaptivitysizingweight";
903  case 41:
904  return "guidemode";
905  case 42:
906  return "localguideweight";
907 
908  }
909  return 0;
910  }
911 
912  ParmType getNestParmType(TempIndex fieldnum) const override
913  {
914  if (fieldnum.size() < 1)
915  return PARM_UNSUPPORTED;
916  switch (fieldnum[0])
917  {
918  case 0:
919  return PARM_STRING;
920  case 1:
921  return PARM_INTEGER;
922  case 2:
923  return PARM_INTEGER;
924  case 3:
925  return PARM_INTEGER;
926  case 4:
927  return PARM_INTEGER;
928  case 5:
929  return PARM_INTEGER;
930  case 6:
931  return PARM_FLOAT;
932  case 7:
933  return PARM_FLOAT;
934  case 8:
935  return PARM_INTEGER;
936  case 9:
937  return PARM_INTEGER;
938  case 10:
939  return PARM_FLOAT;
940  case 11:
941  return PARM_VECTOR3;
942  case 12:
943  return PARM_INTEGER;
944  case 13:
945  return PARM_INTEGER;
946  case 14:
947  return PARM_INTEGER;
948  case 15:
949  return PARM_INTEGER;
950  case 16:
951  return PARM_INTEGER;
952  case 17:
953  return PARM_INTEGER;
954  case 18:
955  return PARM_INTEGER;
956  case 19:
957  return PARM_INTEGER;
958  case 20:
959  return PARM_FLOAT;
960  case 21:
961  return PARM_STRING;
962  case 22:
963  return PARM_INTEGER;
964  case 23:
965  return PARM_STRING;
966  case 24:
967  return PARM_INTEGER;
968  case 25:
969  return PARM_INTEGER;
970  case 26:
971  return PARM_FLOAT;
972  case 27:
973  return PARM_STRING;
974  case 28:
975  return PARM_INTEGER;
976  case 29:
977  return PARM_FLOAT;
978  case 30:
979  return PARM_STRING;
980  case 31:
981  return PARM_FLOAT;
982  case 32:
983  return PARM_INTEGER;
984  case 33:
985  return PARM_INTEGER;
986  case 34:
987  return PARM_FLOAT;
988  case 35:
989  return PARM_STRING;
990  case 36:
991  return PARM_FLOAT;
992  case 37:
993  return PARM_INTEGER;
994  case 38:
995  return PARM_STRING;
996  case 39:
997  return PARM_STRING;
998  case 40:
999  return PARM_FLOAT;
1000  case 41:
1001  return PARM_INTEGER;
1002  case 42:
1003  return PARM_FLOAT;
1004 
1005  }
1006  return PARM_UNSUPPORTED;
1007  }
1008 
1009  // Boiler plate to load individual types.
1010  static void loadData(UT_IStream &is, int64 &v)
1011  { is.bread(&v, 1); }
1012  static void loadData(UT_IStream &is, bool &v)
1013  { int64 iv; is.bread(&iv, 1); v = iv; }
1014  static void loadData(UT_IStream &is, fpreal64 &v)
1015  { is.bread<fpreal64>(&v, 1); }
1016  static void loadData(UT_IStream &is, UT_Vector2D &v)
1017  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
1018  static void loadData(UT_IStream &is, UT_Vector3D &v)
1019  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1020  is.bread<fpreal64>(&v.z(), 1); }
1021  static void loadData(UT_IStream &is, UT_Vector4D &v)
1022  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1023  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
1024  static void loadData(UT_IStream &is, UT_Matrix2D &v)
1025  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
1026  static void loadData(UT_IStream &is, UT_Matrix3D &v)
1027  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
1028  static void loadData(UT_IStream &is, UT_Matrix4D &v)
1029  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
1030  static void loadData(UT_IStream &is, UT_Vector2I &v)
1031  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
1032  static void loadData(UT_IStream &is, UT_Vector3I &v)
1033  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1034  is.bread<int64>(&v.z(), 1); }
1035  static void loadData(UT_IStream &is, UT_Vector4I &v)
1036  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1037  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
1039  { is.bread(v); }
1041  { UT_StringHolder rampdata;
1042  loadData(is, rampdata);
1043  if (rampdata.isstring())
1044  {
1045  v.reset(new UT_Ramp());
1046  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
1047  v->load(istr);
1048  }
1049  else v.reset();
1050  }
1053  loadData(is, data);
1054  if (data.isstring())
1055  {
1056  // Find the data type.
1057  const char *colon = UT_StringWrap(data).findChar(':');
1058  if (colon)
1059  {
1060  int typelen = colon - data.buffer();
1062  type.strncpy(data.buffer(), typelen);
1063  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1064 
1065  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1066  }
1067  }
1068  else v.reset();
1069  }
1070 
1071  static void saveData(std::ostream &os, int64 v)
1072  { UTwrite(os, &v); }
1073  static void saveData(std::ostream &os, bool v)
1074  { int64 iv = v; UTwrite(os, &iv); }
1075  static void saveData(std::ostream &os, fpreal64 v)
1076  { UTwrite<fpreal64>(os, &v); }
1077  static void saveData(std::ostream &os, UT_Vector2D v)
1078  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1079  static void saveData(std::ostream &os, UT_Vector3D v)
1080  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1081  UTwrite<fpreal64>(os, &v.z()); }
1082  static void saveData(std::ostream &os, UT_Vector4D v)
1083  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1084  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1085  static void saveData(std::ostream &os, UT_Matrix2D v)
1087  static void saveData(std::ostream &os, UT_Matrix3D v)
1089  static void saveData(std::ostream &os, UT_Matrix4D v)
1091  static void saveData(std::ostream &os, UT_StringHolder s)
1092  { UT_StringWrap(s).saveBinary(os); }
1093  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1095  UT_OStringStream ostr;
1096  if (s) s->save(ostr);
1097  result = ostr.str();
1098  saveData(os, result);
1099  }
1100  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1102  UT_OStringStream ostr;
1103  if (s)
1104  {
1105  ostr << s->getDataTypeToken();
1106  ostr << ":";
1107  s->saveBinary(ostr);
1108  }
1109  result = ostr.str();
1110  saveData(os, result);
1111  }
1112 
1113 
1114  void save(std::ostream &os) const
1115  {
1116  int32 v = version();
1117  UTwrite(os, &v);
1118  saveData(os, myGroup);
1119  saveData(os, myDecimation);
1120  saveData(os, myDecimationLevel);
1121  saveData(os, myOutput);
1122  saveData(os, myResolutionMode);
1123  saveData(os, myTargetQuadCount);
1124  saveData(os, myTargetQuadArea);
1125  saveData(os, myTargetTolerance);
1126  saveData(os, myResolutionScale);
1127  saveData(os, myResolutionSource);
1128  saveData(os, myTriangleArea);
1129  saveData(os, mySymmetryCenter);
1130  saveData(os, myXAxis);
1131  saveData(os, myXDirection);
1132  saveData(os, myYAxis);
1133  saveData(os, myYDirection);
1134  saveData(os, myZAxis);
1135  saveData(os, myZDirection);
1136  saveData(os, myMirrorOutput);
1137  saveData(os, myEnableAdaptivity);
1138  saveData(os, myAdaptivityWeight);
1139  saveData(os, myAdaptivityMaskAttrib);
1140  saveData(os, myAdaptivitySizing);
1141  saveData(os, myAdaptivitySizingAttrib);
1142  saveData(os, myFeatureBoundaries);
1143  saveData(os, myField);
1144  saveData(os, myGlobalWeight);
1145  saveData(os, myGlobalMask);
1146  saveData(os, myCurvature);
1147  saveData(os, myLocalCurvatureWeight);
1148  saveData(os, myCurvatureMaskAttrib);
1149  saveData(os, myCurvatureRotation);
1150  saveData(os, myBoundary);
1151  saveData(os, myBoundaryMode);
1152  saveData(os, myLocalBoundaryWeight);
1153  saveData(os, myBoundaryMaskAttrib);
1154  saveData(os, myBoundaryRotation);
1155  saveData(os, myGuide);
1156  saveData(os, myGuideMaskAttrib);
1157  saveData(os, myGuideAttrib);
1158  saveData(os, myAdaptivitySizingWeight);
1159  saveData(os, myGuideMode);
1160  saveData(os, myLocalGuideWeight);
1161 
1162  }
1163 
1164  bool load(UT_IStream &is)
1165  {
1166  int32 v;
1167  is.bread(&v, 1);
1168  if (version() != v)
1169  {
1170  // Fail incompatible versions
1171  return false;
1172  }
1173  loadData(is, myGroup);
1174  loadData(is, myDecimation);
1175  loadData(is, myDecimationLevel);
1176  loadData(is, myOutput);
1177  loadData(is, myResolutionMode);
1178  loadData(is, myTargetQuadCount);
1179  loadData(is, myTargetQuadArea);
1180  loadData(is, myTargetTolerance);
1181  loadData(is, myResolutionScale);
1182  loadData(is, myResolutionSource);
1183  loadData(is, myTriangleArea);
1184  loadData(is, mySymmetryCenter);
1185  loadData(is, myXAxis);
1186  loadData(is, myXDirection);
1187  loadData(is, myYAxis);
1188  loadData(is, myYDirection);
1189  loadData(is, myZAxis);
1190  loadData(is, myZDirection);
1191  loadData(is, myMirrorOutput);
1192  loadData(is, myEnableAdaptivity);
1193  loadData(is, myAdaptivityWeight);
1194  loadData(is, myAdaptivityMaskAttrib);
1195  loadData(is, myAdaptivitySizing);
1196  loadData(is, myAdaptivitySizingAttrib);
1197  loadData(is, myFeatureBoundaries);
1198  loadData(is, myField);
1199  loadData(is, myGlobalWeight);
1200  loadData(is, myGlobalMask);
1201  loadData(is, myCurvature);
1202  loadData(is, myLocalCurvatureWeight);
1203  loadData(is, myCurvatureMaskAttrib);
1204  loadData(is, myCurvatureRotation);
1205  loadData(is, myBoundary);
1206  loadData(is, myBoundaryMode);
1207  loadData(is, myLocalBoundaryWeight);
1208  loadData(is, myBoundaryMaskAttrib);
1209  loadData(is, myBoundaryRotation);
1210  loadData(is, myGuide);
1211  loadData(is, myGuideMaskAttrib);
1212  loadData(is, myGuideAttrib);
1213  loadData(is, myAdaptivitySizingWeight);
1214  loadData(is, myGuideMode);
1215  loadData(is, myLocalGuideWeight);
1216 
1217  return true;
1218  }
1219 
1220  const UT_StringHolder & getGroup() const { return myGroup; }
1221  void setGroup(const UT_StringHolder & val) { myGroup = val; }
1223  {
1224  SOP_Node *thissop = cookparms.getNode();
1225  if (!thissop) return getGroup();
1227  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
1228  return result;
1229  }
1230  bool getDecimation() const { return myDecimation; }
1231  void setDecimation(bool val) { myDecimation = val; }
1232  bool opDecimation(const SOP_NodeVerb::CookParms &cookparms) const
1233  {
1234  SOP_Node *thissop = cookparms.getNode();
1235  if (!thissop) return getDecimation();
1236  bool result;
1237  OP_Utils::evalOpParm(result, thissop, "decimation", cookparms.getCookTime(), 0);
1238  return result;
1239  }
1240  int64 getDecimationLevel() const { return myDecimationLevel; }
1241  void setDecimationLevel(int64 val) { myDecimationLevel = val; }
1243  {
1244  SOP_Node *thissop = cookparms.getNode();
1245  if (!thissop) return getDecimationLevel();
1246  int64 result;
1247  OP_Utils::evalOpParm(result, thissop, "decimationlevel", cookparms.getCookTime(), 0);
1248  return result;
1249  }
1250  Output getOutput() const { return Output(myOutput); }
1251  void setOutput(Output val) { myOutput = int64(val); }
1252  Output opOutput(const SOP_NodeVerb::CookParms &cookparms) const
1253  {
1254  SOP_Node *thissop = cookparms.getNode();
1255  if (!thissop) return getOutput();
1256  int64 result;
1257  OP_Utils::evalOpParm(result, thissop, "output", cookparms.getCookTime(), 0);
1258  return Output(result);
1259  }
1260  ResolutionMode getResolutionMode() const { return ResolutionMode(myResolutionMode); }
1261  void setResolutionMode(ResolutionMode val) { myResolutionMode = int64(val); }
1263  {
1264  SOP_Node *thissop = cookparms.getNode();
1265  if (!thissop) return getResolutionMode();
1266  int64 result;
1267  OP_Utils::evalOpParm(result, thissop, "resolution", cookparms.getCookTime(), 0);
1268  return ResolutionMode(result);
1269  }
1270  int64 getTargetQuadCount() const { return myTargetQuadCount; }
1271  void setTargetQuadCount(int64 val) { myTargetQuadCount = val; }
1273  {
1274  SOP_Node *thissop = cookparms.getNode();
1275  if (!thissop) return getTargetQuadCount();
1276  int64 result;
1277  OP_Utils::evalOpParm(result, thissop, "targetquadcount", cookparms.getCookTime(), 0);
1278  return result;
1279  }
1280  fpreal64 getTargetQuadArea() const { return myTargetQuadArea; }
1281  void setTargetQuadArea(fpreal64 val) { myTargetQuadArea = val; }
1283  {
1284  SOP_Node *thissop = cookparms.getNode();
1285  if (!thissop) return getTargetQuadArea();
1286  fpreal64 result;
1287  OP_Utils::evalOpParm(result, thissop, "targetquadarea", cookparms.getCookTime(), 0);
1288  return result;
1289  }
1290  fpreal64 getTargetTolerance() const { return myTargetTolerance; }
1291  void setTargetTolerance(fpreal64 val) { myTargetTolerance = val; }
1293  {
1294  SOP_Node *thissop = cookparms.getNode();
1295  if (!thissop) return getTargetTolerance();
1296  fpreal64 result;
1297  OP_Utils::evalOpParm(result, thissop, "targettolerance", cookparms.getCookTime(), 0);
1298  return result;
1299  }
1300  int64 getResolutionScale() const { return myResolutionScale; }
1301  void setResolutionScale(int64 val) { myResolutionScale = val; }
1303  {
1304  SOP_Node *thissop = cookparms.getNode();
1305  if (!thissop) return getResolutionScale();
1306  int64 result;
1307  OP_Utils::evalOpParm(result, thissop, "resolutionscale", cookparms.getCookTime(), 0);
1308  return result;
1309  }
1310  ResolutionSource getResolutionSource() const { return ResolutionSource(myResolutionSource); }
1311  void setResolutionSource(ResolutionSource val) { myResolutionSource = int64(val); }
1313  {
1314  SOP_Node *thissop = cookparms.getNode();
1315  if (!thissop) return getResolutionSource();
1316  int64 result;
1317  OP_Utils::evalOpParm(result, thissop, "resolutionsource", cookparms.getCookTime(), 0);
1318  return ResolutionSource(result);
1319  }
1320  fpreal64 getTriangleArea() const { return myTriangleArea; }
1321  void setTriangleArea(fpreal64 val) { myTriangleArea = val; }
1323  {
1324  SOP_Node *thissop = cookparms.getNode();
1325  if (!thissop) return getTriangleArea();
1326  fpreal64 result;
1327  OP_Utils::evalOpParm(result, thissop, "trianglearea", cookparms.getCookTime(), 0);
1328  return result;
1329  }
1330  UT_Vector3D getSymmetryCenter() const { return mySymmetryCenter; }
1331  void setSymmetryCenter(UT_Vector3D val) { mySymmetryCenter = val; }
1333  {
1334  SOP_Node *thissop = cookparms.getNode();
1335  if (!thissop) return getSymmetryCenter();
1337  OP_Utils::evalOpParm(result, thissop, "symmetrycenter", cookparms.getCookTime(), 0);
1338  return result;
1339  }
1340  bool getXAxis() const { return myXAxis; }
1341  void setXAxis(bool val) { myXAxis = val; }
1342  bool opXAxis(const SOP_NodeVerb::CookParms &cookparms) const
1343  {
1344  SOP_Node *thissop = cookparms.getNode();
1345  if (!thissop) return getXAxis();
1346  bool result;
1347  OP_Utils::evalOpParm(result, thissop, "xaxis", cookparms.getCookTime(), 0);
1348  return result;
1349  }
1350  XDirection getXDirection() const { return XDirection(myXDirection); }
1351  void setXDirection(XDirection val) { myXDirection = int64(val); }
1353  {
1354  SOP_Node *thissop = cookparms.getNode();
1355  if (!thissop) return getXDirection();
1356  int64 result;
1357  OP_Utils::evalOpParm(result, thissop, "xdirection", cookparms.getCookTime(), 0);
1358  return XDirection(result);
1359  }
1360  bool getYAxis() const { return myYAxis; }
1361  void setYAxis(bool val) { myYAxis = val; }
1362  bool opYAxis(const SOP_NodeVerb::CookParms &cookparms) const
1363  {
1364  SOP_Node *thissop = cookparms.getNode();
1365  if (!thissop) return getYAxis();
1366  bool result;
1367  OP_Utils::evalOpParm(result, thissop, "yaxis", cookparms.getCookTime(), 0);
1368  return result;
1369  }
1370  YDirection getYDirection() const { return YDirection(myYDirection); }
1371  void setYDirection(YDirection val) { myYDirection = int64(val); }
1373  {
1374  SOP_Node *thissop = cookparms.getNode();
1375  if (!thissop) return getYDirection();
1376  int64 result;
1377  OP_Utils::evalOpParm(result, thissop, "ydirection", cookparms.getCookTime(), 0);
1378  return YDirection(result);
1379  }
1380  bool getZAxis() const { return myZAxis; }
1381  void setZAxis(bool val) { myZAxis = val; }
1382  bool opZAxis(const SOP_NodeVerb::CookParms &cookparms) const
1383  {
1384  SOP_Node *thissop = cookparms.getNode();
1385  if (!thissop) return getZAxis();
1386  bool result;
1387  OP_Utils::evalOpParm(result, thissop, "zaxis", cookparms.getCookTime(), 0);
1388  return result;
1389  }
1390  ZDirection getZDirection() const { return ZDirection(myZDirection); }
1391  void setZDirection(ZDirection val) { myZDirection = int64(val); }
1393  {
1394  SOP_Node *thissop = cookparms.getNode();
1395  if (!thissop) return getZDirection();
1396  int64 result;
1397  OP_Utils::evalOpParm(result, thissop, "zdirection", cookparms.getCookTime(), 0);
1398  return ZDirection(result);
1399  }
1400  bool getMirrorOutput() const { return myMirrorOutput; }
1401  void setMirrorOutput(bool val) { myMirrorOutput = val; }
1402  bool opMirrorOutput(const SOP_NodeVerb::CookParms &cookparms) const
1403  {
1404  SOP_Node *thissop = cookparms.getNode();
1405  if (!thissop) return getMirrorOutput();
1406  bool result;
1407  OP_Utils::evalOpParm(result, thissop, "mirroroutput", cookparms.getCookTime(), 0);
1408  return result;
1409  }
1410  bool getEnableAdaptivity() const { return myEnableAdaptivity; }
1411  void setEnableAdaptivity(bool val) { myEnableAdaptivity = val; }
1412  bool opEnableAdaptivity(const SOP_NodeVerb::CookParms &cookparms) const
1413  {
1414  SOP_Node *thissop = cookparms.getNode();
1415  if (!thissop) return getEnableAdaptivity();
1416  bool result;
1417  OP_Utils::evalOpParm(result, thissop, "enableadaptivity", cookparms.getCookTime(), 0);
1418  return result;
1419  }
1420  fpreal64 getAdaptivityWeight() const { return myAdaptivityWeight; }
1421  void setAdaptivityWeight(fpreal64 val) { myAdaptivityWeight = val; }
1423  {
1424  SOP_Node *thissop = cookparms.getNode();
1425  if (!thissop) return getAdaptivityWeight();
1426  fpreal64 result;
1427  OP_Utils::evalOpParm(result, thissop, "adaptivityweight", cookparms.getCookTime(), 0);
1428  return result;
1429  }
1430  const UT_StringHolder & getAdaptivityMaskAttrib() const { return myAdaptivityMaskAttrib; }
1431  void setAdaptivityMaskAttrib(const UT_StringHolder & val) { myAdaptivityMaskAttrib = val; }
1433  {
1434  SOP_Node *thissop = cookparms.getNode();
1435  if (!thissop) return getAdaptivityMaskAttrib();
1437  OP_Utils::evalOpParm(result, thissop, "adaptivitymaskattrib", cookparms.getCookTime(), 0);
1438  return result;
1439  }
1440  bool getAdaptivitySizing() const { return myAdaptivitySizing; }
1441  void setAdaptivitySizing(bool val) { myAdaptivitySizing = val; }
1442  bool opAdaptivitySizing(const SOP_NodeVerb::CookParms &cookparms) const
1443  {
1444  SOP_Node *thissop = cookparms.getNode();
1445  if (!thissop) return getAdaptivitySizing();
1446  bool result;
1447  OP_Utils::evalOpParm(result, thissop, "adaptivitysizing", cookparms.getCookTime(), 0);
1448  return result;
1449  }
1450  const UT_StringHolder & getAdaptivitySizingAttrib() const { return myAdaptivitySizingAttrib; }
1451  void setAdaptivitySizingAttrib(const UT_StringHolder & val) { myAdaptivitySizingAttrib = val; }
1453  {
1454  SOP_Node *thissop = cookparms.getNode();
1455  if (!thissop) return getAdaptivitySizingAttrib();
1457  OP_Utils::evalOpParm(result, thissop, "adaptivitysizingattrib", cookparms.getCookTime(), 0);
1458  return result;
1459  }
1460  bool getFeatureBoundaries() const { return myFeatureBoundaries; }
1461  void setFeatureBoundaries(bool val) { myFeatureBoundaries = val; }
1462  bool opFeatureBoundaries(const SOP_NodeVerb::CookParms &cookparms) const
1463  {
1464  SOP_Node *thissop = cookparms.getNode();
1465  if (!thissop) return getFeatureBoundaries();
1466  bool result;
1467  OP_Utils::evalOpParm(result, thissop, "featureboundaries", cookparms.getCookTime(), 0);
1468  return result;
1469  }
1470  Field getField() const { return Field(myField); }
1471  void setField(Field val) { myField = int64(val); }
1472  Field opField(const SOP_NodeVerb::CookParms &cookparms) const
1473  {
1474  SOP_Node *thissop = cookparms.getNode();
1475  if (!thissop) return getField();
1476  int64 result;
1477  OP_Utils::evalOpParm(result, thissop, "field", cookparms.getCookTime(), 0);
1478  return Field(result);
1479  }
1480  fpreal64 getGlobalWeight() const { return myGlobalWeight; }
1481  void setGlobalWeight(fpreal64 val) { myGlobalWeight = val; }
1483  {
1484  SOP_Node *thissop = cookparms.getNode();
1485  if (!thissop) return getGlobalWeight();
1486  fpreal64 result;
1487  OP_Utils::evalOpParm(result, thissop, "globalweight", cookparms.getCookTime(), 0);
1488  return result;
1489  }
1490  const UT_StringHolder & getGlobalMask() const { return myGlobalMask; }
1491  void setGlobalMask(const UT_StringHolder & val) { myGlobalMask = val; }
1493  {
1494  SOP_Node *thissop = cookparms.getNode();
1495  if (!thissop) return getGlobalMask();
1497  OP_Utils::evalOpParm(result, thissop, "globalmask", cookparms.getCookTime(), 0);
1498  return result;
1499  }
1500  bool getCurvature() const { return myCurvature; }
1501  void setCurvature(bool val) { myCurvature = val; }
1502  bool opCurvature(const SOP_NodeVerb::CookParms &cookparms) const
1503  {
1504  SOP_Node *thissop = cookparms.getNode();
1505  if (!thissop) return getCurvature();
1506  bool result;
1507  OP_Utils::evalOpParm(result, thissop, "curvature", cookparms.getCookTime(), 0);
1508  return result;
1509  }
1510  fpreal64 getLocalCurvatureWeight() const { return myLocalCurvatureWeight; }
1511  void setLocalCurvatureWeight(fpreal64 val) { myLocalCurvatureWeight = val; }
1513  {
1514  SOP_Node *thissop = cookparms.getNode();
1515  if (!thissop) return getLocalCurvatureWeight();
1516  fpreal64 result;
1517  OP_Utils::evalOpParm(result, thissop, "localcurvatureweight", cookparms.getCookTime(), 0);
1518  return result;
1519  }
1520  const UT_StringHolder & getCurvatureMaskAttrib() const { return myCurvatureMaskAttrib; }
1521  void setCurvatureMaskAttrib(const UT_StringHolder & val) { myCurvatureMaskAttrib = val; }
1523  {
1524  SOP_Node *thissop = cookparms.getNode();
1525  if (!thissop) return getCurvatureMaskAttrib();
1527  OP_Utils::evalOpParm(result, thissop, "curvaturemaskattrib", cookparms.getCookTime(), 0);
1528  return result;
1529  }
1530  fpreal64 getCurvatureRotation() const { return myCurvatureRotation; }
1531  void setCurvatureRotation(fpreal64 val) { myCurvatureRotation = val; }
1533  {
1534  SOP_Node *thissop = cookparms.getNode();
1535  if (!thissop) return getCurvatureRotation();
1536  fpreal64 result;
1537  OP_Utils::evalOpParm(result, thissop, "curvaturerotation", cookparms.getCookTime(), 0);
1538  return result;
1539  }
1540  bool getBoundary() const { return myBoundary; }
1541  void setBoundary(bool val) { myBoundary = val; }
1542  bool opBoundary(const SOP_NodeVerb::CookParms &cookparms) const
1543  {
1544  SOP_Node *thissop = cookparms.getNode();
1545  if (!thissop) return getBoundary();
1546  bool result;
1547  OP_Utils::evalOpParm(result, thissop, "boundary", cookparms.getCookTime(), 0);
1548  return result;
1549  }
1550  BoundaryMode getBoundaryMode() const { return BoundaryMode(myBoundaryMode); }
1551  void setBoundaryMode(BoundaryMode val) { myBoundaryMode = int64(val); }
1553  {
1554  SOP_Node *thissop = cookparms.getNode();
1555  if (!thissop) return getBoundaryMode();
1556  int64 result;
1557  OP_Utils::evalOpParm(result, thissop, "boundarymode", cookparms.getCookTime(), 0);
1558  return BoundaryMode(result);
1559  }
1560  fpreal64 getLocalBoundaryWeight() const { return myLocalBoundaryWeight; }
1561  void setLocalBoundaryWeight(fpreal64 val) { myLocalBoundaryWeight = val; }
1563  {
1564  SOP_Node *thissop = cookparms.getNode();
1565  if (!thissop) return getLocalBoundaryWeight();
1566  fpreal64 result;
1567  OP_Utils::evalOpParm(result, thissop, "localboundaryweight", cookparms.getCookTime(), 0);
1568  return result;
1569  }
1570  const UT_StringHolder & getBoundaryMaskAttrib() const { return myBoundaryMaskAttrib; }
1571  void setBoundaryMaskAttrib(const UT_StringHolder & val) { myBoundaryMaskAttrib = val; }
1573  {
1574  SOP_Node *thissop = cookparms.getNode();
1575  if (!thissop) return getBoundaryMaskAttrib();
1577  OP_Utils::evalOpParm(result, thissop, "boundarymaskattrib", cookparms.getCookTime(), 0);
1578  return result;
1579  }
1580  fpreal64 getBoundaryRotation() const { return myBoundaryRotation; }
1581  void setBoundaryRotation(fpreal64 val) { myBoundaryRotation = val; }
1583  {
1584  SOP_Node *thissop = cookparms.getNode();
1585  if (!thissop) return getBoundaryRotation();
1586  fpreal64 result;
1587  OP_Utils::evalOpParm(result, thissop, "boundaryrotation", cookparms.getCookTime(), 0);
1588  return result;
1589  }
1590  bool getGuide() const { return myGuide; }
1591  void setGuide(bool val) { myGuide = val; }
1592  bool opGuide(const SOP_NodeVerb::CookParms &cookparms) const
1593  {
1594  SOP_Node *thissop = cookparms.getNode();
1595  if (!thissop) return getGuide();
1596  bool result;
1597  OP_Utils::evalOpParm(result, thissop, "guide", cookparms.getCookTime(), 0);
1598  return result;
1599  }
1600  const UT_StringHolder & getGuideMaskAttrib() const { return myGuideMaskAttrib; }
1601  void setGuideMaskAttrib(const UT_StringHolder & val) { myGuideMaskAttrib = val; }
1603  {
1604  SOP_Node *thissop = cookparms.getNode();
1605  if (!thissop) return getGuideMaskAttrib();
1607  OP_Utils::evalOpParm(result, thissop, "guidemaskattrib", cookparms.getCookTime(), 0);
1608  return result;
1609  }
1610  const UT_StringHolder & getGuideAttrib() const { return myGuideAttrib; }
1611  void setGuideAttrib(const UT_StringHolder & val) { myGuideAttrib = val; }
1613  {
1614  SOP_Node *thissop = cookparms.getNode();
1615  if (!thissop) return getGuideAttrib();
1617  OP_Utils::evalOpParm(result, thissop, "guideattrib", cookparms.getCookTime(), 0);
1618  return result;
1619  }
1620  fpreal64 getAdaptivitySizingWeight() const { return myAdaptivitySizingWeight; }
1621  void setAdaptivitySizingWeight(fpreal64 val) { myAdaptivitySizingWeight = val; }
1623  {
1624  SOP_Node *thissop = cookparms.getNode();
1625  if (!thissop) return getAdaptivitySizingWeight();
1626  fpreal64 result;
1627  OP_Utils::evalOpParm(result, thissop, "adaptivitysizingweight", cookparms.getCookTime(), 0);
1628  return result;
1629  }
1630  GuideMode getGuideMode() const { return GuideMode(myGuideMode); }
1631  void setGuideMode(GuideMode val) { myGuideMode = int64(val); }
1633  {
1634  SOP_Node *thissop = cookparms.getNode();
1635  if (!thissop) return getGuideMode();
1636  int64 result;
1637  OP_Utils::evalOpParm(result, thissop, "guidemode", cookparms.getCookTime(), 0);
1638  return GuideMode(result);
1639  }
1640  fpreal64 getLocalGuideWeight() const { return myLocalGuideWeight; }
1641  void setLocalGuideWeight(fpreal64 val) { myLocalGuideWeight = val; }
1643  {
1644  SOP_Node *thissop = cookparms.getNode();
1645  if (!thissop) return getLocalGuideWeight();
1646  fpreal64 result;
1647  OP_Utils::evalOpParm(result, thissop, "localguideweight", cookparms.getCookTime(), 0);
1648  return result;
1649  }
1650 
1651 private:
1652  UT_StringHolder myGroup;
1653  bool myDecimation;
1654  int64 myDecimationLevel;
1655  int64 myOutput;
1656  int64 myResolutionMode;
1657  int64 myTargetQuadCount;
1658  fpreal64 myTargetQuadArea;
1659  fpreal64 myTargetTolerance;
1660  int64 myResolutionScale;
1661  int64 myResolutionSource;
1662  fpreal64 myTriangleArea;
1663  UT_Vector3D mySymmetryCenter;
1664  bool myXAxis;
1665  int64 myXDirection;
1666  bool myYAxis;
1667  int64 myYDirection;
1668  bool myZAxis;
1669  int64 myZDirection;
1670  bool myMirrorOutput;
1671  bool myEnableAdaptivity;
1672  fpreal64 myAdaptivityWeight;
1673  UT_StringHolder myAdaptivityMaskAttrib;
1674  bool myAdaptivitySizing;
1675  UT_StringHolder myAdaptivitySizingAttrib;
1676  bool myFeatureBoundaries;
1677  int64 myField;
1678  fpreal64 myGlobalWeight;
1679  UT_StringHolder myGlobalMask;
1680  bool myCurvature;
1681  fpreal64 myLocalCurvatureWeight;
1682  UT_StringHolder myCurvatureMaskAttrib;
1683  fpreal64 myCurvatureRotation;
1684  bool myBoundary;
1685  int64 myBoundaryMode;
1686  fpreal64 myLocalBoundaryWeight;
1687  UT_StringHolder myBoundaryMaskAttrib;
1688  fpreal64 myBoundaryRotation;
1689  bool myGuide;
1690  UT_StringHolder myGuideMaskAttrib;
1691  UT_StringHolder myGuideAttrib;
1692  fpreal64 myAdaptivitySizingWeight;
1693  int64 myGuideMode;
1694  fpreal64 myLocalGuideWeight;
1695 
1696 };
BoundaryMode getBoundaryMode() const
void setAdaptivityWeight(fpreal64 val)
BoundaryMode opBoundaryMode(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getSymmetryCenter() const
type
Definition: core.h:556
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
static void saveData(std::ostream &os, UT_Vector3D v)
static void saveData(std::ostream &os, UT_Vector4D v)
void setTargetQuadArea(fpreal64 val)
void setCurvatureRotation(fpreal64 val)
void setLocalCurvatureWeight(fpreal64 val)
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
int int32
Definition: SYS_Types.h:39
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:347
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
fpreal64 opCurvatureRotation(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
static void loadData(UT_IStream &is, UT_Vector3D &v)
void setYDirection(YDirection val)
const UT_StringHolder & getGlobalMask() const
bool opBoundary(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opGuideAttrib(const SOP_NodeVerb::CookParms &cookparms) const
YDirection opYDirection(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix2D v)
fpreal64 opTargetQuadArea(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4D &v)
const UT_StringHolder & getGuideMaskAttrib() const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
exint bread(int32 *buffer, exint asize=1)
XDirection opXDirection(const SOP_NodeVerb::CookParms &cookparms) const
GLboolean * data
Definition: glcorearb.h:131
int64 getResolutionScale() const
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:63
const UT_StringHolder & getGuideAttrib() const
bool opGuide(const SOP_NodeVerb::CookParms &cookparms) const
GLsizei const GLfloat * value
Definition: glcorearb.h:824
fpreal64 getLocalBoundaryWeight() const
Output opOutput(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, bool &v)
void save(std::ostream &os) const
UT_StringHolder opGlobalMask(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, fpreal64 v)
fpreal64 getTriangleArea() const
fpreal64 opAdaptivitySizingWeight(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opTargetTolerance(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opGuideMaskAttrib(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opSymmetryCenter(const SOP_NodeVerb::CookParms &cookparms) const
const OP_Context & context() const
Definition: OP_NodeParms.h:97
bool opDecimation(const SOP_NodeVerb::CookParms &cookparms) const
void setOutput(Output val)
UT_StringHolder opAdaptivityMaskAttrib(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
exint getNestNumParms(TempIndex idx) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
void setAdaptivitySizingAttrib(const UT_StringHolder &val)
GLdouble s
Definition: glad.h:3009
bool opFeatureBoundaries(const SOP_NodeVerb::CookParms &cookparms) const
const char * getNestParmName(TempIndex fieldnum) const override
void setResolutionMode(ResolutionMode val)
An output stream object that owns its own string buffer storage.
bool opAdaptivitySizing(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getBoundaryRotation() const
bool opEnableAdaptivity(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
void setBoundaryMaskAttrib(const UT_StringHolder &val)
**But if you need a result
Definition: thread.h:622
void setGlobalWeight(fpreal64 val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
void setGuideAttrib(const UT_StringHolder &val)
static void saveData(std::ostream &os, UT_Matrix3D 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.
fpreal64 getLocalCurvatureWeight() const
fpreal64 opAdaptivityWeight(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector4.h:491
fpreal64 getTargetTolerance() const
fpreal64 getAdaptivitySizingWeight() const
GuideMode getGuideMode() const
void setResolutionSource(ResolutionSource val)
fpreal64 getAdaptivityWeight() const
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
ResolutionSource getResolutionSource() const
UT_StringHolder opCurvatureMaskAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setEnableAdaptivity(bool val)
double fpreal64
Definition: SYS_Types.h:201
const UT_StringHolder & getAdaptivityMaskAttrib() const
bool opCurvature(const SOP_NodeVerb::CookParms &cookparms) const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: APEX_Include.h:55
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector2.h:423
ParmType getNestParmType(TempIndex fieldnum) const override
void setCurvatureMaskAttrib(const UT_StringHolder &val)
int64 opResolutionScale(const SOP_NodeVerb::CookParms &cookparms) const
ResolutionMode opResolutionMode(const SOP_NodeVerb::CookParms &cookparms) const
int64 getTargetQuadCount() const
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
ResolutionSource opResolutionSource(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opBoundaryRotation(const SOP_NodeVerb::CookParms &cookparms) const
bool opYAxis(const SOP_NodeVerb::CookParms &cookparms) const
Field opField(const SOP_NodeVerb::CookParms &cookparms) const
void setMirrorOutput(bool val)
YDirection getYDirection() const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
UT_StringHolder opAdaptivitySizingAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool isParmColorRamp(exint idx) const override
exint length() const
fpreal64 opLocalCurvatureWeight(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
int64 opTargetQuadCount(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector4.h:495
bool opMirrorOutput(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE UT_StringHolder getToken(Output enum_value)
static void loadData(UT_IStream &is, int64 &v)
void loadFromOpSubclass(const LoadParms &loadparms) override
const OP_GraphProxy * graph() const
Definition: OP_NodeParms.h:94
void setBoundaryRotation(fpreal64 val)
bool getFeatureBoundaries() const
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
bool load(UT_IStream &is)
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
bool opZAxis(const SOP_NodeVerb::CookParms &cookparms) const
void setGuideMode(GuideMode val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void setLocalGuideWeight(fpreal64 val)
void setZDirection(ZDirection val)
int64 getDecimationLevel() const
long long int64
Definition: SYS_Types.h:116
ZDirection getZDirection() const
ZDirection opZDirection(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3T< fpreal64 > UT_Vector3D
static void saveData(std::ostream &os, int64 v)
void setGroup(const UT_StringHolder &val)
static void saveData(std::ostream &os, UT_StringHolder s)
void setGuideMaskAttrib(const UT_StringHolder &val)
void setDecimationLevel(int64 val)
static void saveData(std::ostream &os, UT_Vector2D v)
void setGlobalMask(const UT_StringHolder &val)
void setAdaptivitySizingWeight(fpreal64 val)
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
void setLocalBoundaryWeight(fpreal64 val)
static void loadData(UT_IStream &is, fpreal64 &v)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:303
GT_API const UT_StringHolder version
const UT_StringHolder & getBoundaryMaskAttrib() const
static void loadData(UT_IStream &is, UT_Vector3I &v)
fpreal64 getCurvatureRotation() const
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
void setTargetQuadCount(int64 val)
static void loadData(UT_IStream &is, UT_Vector2I &v)
static void saveData(std::ostream &os, UT_Matrix4D v)
int64 opDecimationLevel(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
const UT_StringHolder & getAdaptivitySizingAttrib() const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
ResolutionMode getResolutionMode() const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
fpreal64 fpreal
Definition: SYS_Types.h:278
void setTargetTolerance(fpreal64 val)
DEP_MicroNode * depnode() const
Definition: OP_NodeParms.h:99
void setFeatureBoundaries(bool val)
bool operator!=(const SOP_QuadRemeshParms &src) const
LeafData & operator=(const LeafData &)=delete
bool getEnableAdaptivity() const
Utility class for containing a color ramp.
Definition: UT_Ramp.h:96
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
void setResolutionScale(int64 val)
constexpr SYS_FORCE_INLINE T & w() noexcept
Definition: UT_Vector4.h:497
bool opXAxis(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getGlobalWeight() const
void setXDirection(XDirection val)
GLuint GLfloat * val
Definition: glcorearb.h:1608
static void saveData(std::ostream &os, bool v)
virtual UT_StringHolder baseGetSignature() const
Definition: OP_NodeParms.h:294
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
#define SOP_API
Definition: SOP_API.h:10
void setBoundaryMode(BoundaryMode val)
const UT_StringHolder & getGroup() const
void copyFrom(const OP_NodeParms *src) override
static void loadData(UT_IStream &is, UT_Vector2D &v)
XDirection getXDirection() const
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:372
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
GuideMode opGuideMode(const SOP_NodeVerb::CookParms &cookparms) const
const char * findChar(int c) const
Definition: UT_String.h:1401
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
GLboolean r
Definition: glcorearb.h:1222
fpreal64 opGlobalWeight(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
fpreal64 opTriangleArea(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix4D &v)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
fpreal64 opLocalBoundaryWeight(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector3.h:665
bool operator==(const SOP_QuadRemeshParms &src) const
UT_StringHolder opBoundaryMaskAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setTriangleArea(fpreal64 val)
void setSymmetryCenter(UT_Vector3D val)
virtual bool isDirect() const =0
Direct proxies mirror actual nodes:
static void loadData(UT_IStream &is, UT_StringHolder &v)
bool getAdaptivitySizing() const
fpreal64 opLocalGuideWeight(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getTargetQuadArea() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
void setAdaptivityMaskAttrib(const UT_StringHolder &val)
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector2.h:425
SYS_FORCE_INLINE bool isstring() const
fpreal64 getLocalGuideWeight() const
void setAdaptivitySizing(bool val)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
const UT_StringHolder & getCurvatureMaskAttrib() const
GLenum src
Definition: glcorearb.h:1793
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector3.h:663