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