HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_Boolean.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 <OP/OP_Utils.h>
8 #include <PRM/PRM_Parm.h>
9 #include <UT/UT_IStream.h>
10 #include <UT/UT_NTStreamUtil.h>
11 #include <UT/UT_Ramp.h>
12 #include <UT/UT_SharedPtr.h>
13 #include <UT/UT_StringHolder.h>
14 #include <UT/UT_StringStream.h>
15 #include <UT/UT_VectorTypes.h>
16 #include <SYS/SYS_Types.h>
17 
18 using namespace UT::Literal;
19 
20 class DEP_MicroNode;
21 namespace SOP_BooleanEnums
22 {
23  enum class ASurface
24  {
25  SOLID = 0,
26  SURFACE
27  };
28  enum class BSurface
29  {
30  SOLID = 0,
31  SURFACE
32  };
33  enum class BooleanOp
34  {
35  UNION = 0,
36  INTERSECT,
37  SUBTRACT,
38  SHATTER,
39  CUSTOM,
40  // -- menu separator --
41  SEAM = 6,
42  // -- menu separator --
43  DETECT = 8,
44  RESOLVE
45  };
46  enum class SubtractChoices
47  {
48  AMINUSB = 0,
49  BMINUSA,
50  BOTH
51  };
52  enum class ShatterChoices
53  {
54  APIECES = 0,
55  BPIECES,
56  BOTH
57  };
58  enum class WindingOp
59  {
60  ARANGE = 0,
61  BRANGE,
62  AND,
63  OR,
64  XOR
65  };
66  enum class Detriangulate
67  {
68  NONE = 0,
69  UNCHANGED,
70  ALL
71  };
72 }
73 
74 
76 {
77 public:
78  static int version() { return 1; }
79 
81  {
82  myGroupA = ""_sh;
83  myASurface = 0;
84  myResolveA = true;
85  myGroupB = ""_sh;
86  myBSurface = 0;
87  myResolveB = true;
88  myBooleanOp = 0;
89  mySubtractChoices = 0;
90  myShatterChoices = 0;
91  myOpenCurvesOnly = true;
92  myGenerateAASeams = true;
93  myGenerateBBSeams = true;
94  myGenerateABSeams = true;
95  myWindingOp = 0;
96  myMergeNbrs = false;
97  myDetriangulate = 2;
98  myRemoveInlinePoints = true;
99  myUniqueSeams = false;
100  myUseAxAPolys = false;
101  myAxAPolys = "axapolys"_sh;
102  myUseAxBPolys = false;
103  myAxBPolys = "axbpolys"_sh;
104  myUseAxAList = false;
105  myAxAList = "axalist"_sh;
106  myUseAxBList = false;
107  myAxBList = "axblist"_sh;
108  myCollapseTinyEdges = true;
109  myLengthThreshold = 0.00001;
110  myUseAPolys = false;
111  myAPolys = "apolys"_sh;
112  myUseAInsideB = false;
113  myAInsideB = "ainsideb"_sh;
114  myUseAOutsideB = false;
115  myAOutsideB = "aoutsideb"_sh;
116  myUseBPolys = false;
117  myBPolys = "bpolys"_sh;
118  myUseBInsideA = false;
119  myBInsideA = "binsidea"_sh;
120  myUseBOutsideA = false;
121  myBOutsideA = "boutsidea"_sh;
122  myUseABOverlap = false;
123  myABOverlap = "aboverlap"_sh;
124  myUseAPieces = false;
125  myAPieces = "apieces"_sh;
126  myUseBPieces = false;
127  myBPieces = "bpieces"_sh;
128  myUseABPieces = false;
129  myABPieces = "abpieces"_sh;
130  myUseAASeamEdges = false;
131  myAASeamEdges = "aseams"_sh;
132  myUseBBSeamEdges = false;
133  myBBSeamEdges = "bseams"_sh;
134  myUseABSeamEdges = false;
135  myABSeamEdges = "abseams"_sh;
136  myDepthInA = UT_Vector2I(1,1000);
137  myDepthInB = UT_Vector2I(1,1000);
138 
139  }
140 
141  explicit SOP_BooleanParms(const SOP_BooleanParms &) = default;
142 
143  virtual ~SOP_BooleanParms() {}
144 
145  bool operator==(const SOP_BooleanParms &src) const
146  {
147  if (myGroupA != src.myGroupA) return false;
148  if (myASurface != src.myASurface) return false;
149  if (myResolveA != src.myResolveA) return false;
150  if (myGroupB != src.myGroupB) return false;
151  if (myBSurface != src.myBSurface) return false;
152  if (myResolveB != src.myResolveB) return false;
153  if (myBooleanOp != src.myBooleanOp) return false;
154  if (mySubtractChoices != src.mySubtractChoices) return false;
155  if (myShatterChoices != src.myShatterChoices) return false;
156  if (myOpenCurvesOnly != src.myOpenCurvesOnly) return false;
157  if (myGenerateAASeams != src.myGenerateAASeams) return false;
158  if (myGenerateBBSeams != src.myGenerateBBSeams) return false;
159  if (myGenerateABSeams != src.myGenerateABSeams) return false;
160  if (myWindingOp != src.myWindingOp) return false;
161  if (myMergeNbrs != src.myMergeNbrs) return false;
162  if (myDetriangulate != src.myDetriangulate) return false;
163  if (myRemoveInlinePoints != src.myRemoveInlinePoints) return false;
164  if (myUniqueSeams != src.myUniqueSeams) return false;
165  if (myUseAxAPolys != src.myUseAxAPolys) return false;
166  if (myAxAPolys != src.myAxAPolys) return false;
167  if (myUseAxBPolys != src.myUseAxBPolys) return false;
168  if (myAxBPolys != src.myAxBPolys) return false;
169  if (myUseAxAList != src.myUseAxAList) return false;
170  if (myAxAList != src.myAxAList) return false;
171  if (myUseAxBList != src.myUseAxBList) return false;
172  if (myAxBList != src.myAxBList) return false;
173  if (myCollapseTinyEdges != src.myCollapseTinyEdges) return false;
174  if (myLengthThreshold != src.myLengthThreshold) return false;
175  if (myUseAPolys != src.myUseAPolys) return false;
176  if (myAPolys != src.myAPolys) return false;
177  if (myUseAInsideB != src.myUseAInsideB) return false;
178  if (myAInsideB != src.myAInsideB) return false;
179  if (myUseAOutsideB != src.myUseAOutsideB) return false;
180  if (myAOutsideB != src.myAOutsideB) return false;
181  if (myUseBPolys != src.myUseBPolys) return false;
182  if (myBPolys != src.myBPolys) return false;
183  if (myUseBInsideA != src.myUseBInsideA) return false;
184  if (myBInsideA != src.myBInsideA) return false;
185  if (myUseBOutsideA != src.myUseBOutsideA) return false;
186  if (myBOutsideA != src.myBOutsideA) return false;
187  if (myUseABOverlap != src.myUseABOverlap) return false;
188  if (myABOverlap != src.myABOverlap) return false;
189  if (myUseAPieces != src.myUseAPieces) return false;
190  if (myAPieces != src.myAPieces) return false;
191  if (myUseBPieces != src.myUseBPieces) return false;
192  if (myBPieces != src.myBPieces) return false;
193  if (myUseABPieces != src.myUseABPieces) return false;
194  if (myABPieces != src.myABPieces) return false;
195  if (myUseAASeamEdges != src.myUseAASeamEdges) return false;
196  if (myAASeamEdges != src.myAASeamEdges) return false;
197  if (myUseBBSeamEdges != src.myUseBBSeamEdges) return false;
198  if (myBBSeamEdges != src.myBBSeamEdges) return false;
199  if (myUseABSeamEdges != src.myUseABSeamEdges) return false;
200  if (myABSeamEdges != src.myABSeamEdges) return false;
201  if (myDepthInA != src.myDepthInA) return false;
202  if (myDepthInB != src.myDepthInB) return false;
203 
204  return true;
205  }
206  bool operator!=(const SOP_BooleanParms &src) const
207  {
208  return !operator==(src);
209  }
217 
218 
219 
220  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
221  {
222  if (true)
223  OP_Utils::evalOpParm(myGroupA, node, "agroup", time, 0);
224  else myGroupA = ""_sh;
225  if (true)
226  OP_Utils::evalOpParm(myASurface, node, "asurface", time, 0);
227  else myASurface = 0;
228  if (true)
229  OP_Utils::evalOpParm(myResolveA, node, "resolvea", time, 0);
230  else myResolveA = true;
231  if (true)
232  OP_Utils::evalOpParm(myGroupB, node, "bgroup", time, 0);
233  else myGroupB = ""_sh;
234  if (true)
235  OP_Utils::evalOpParm(myBSurface, node, "bsurface", time, 0);
236  else myBSurface = 0;
237  if (true)
238  OP_Utils::evalOpParm(myResolveB, node, "resolveb", time, 0);
239  else myResolveB = true;
240  if (true)
241  OP_Utils::evalOpParm(myBooleanOp, node, "booleanop", time, 0);
242  else myBooleanOp = 0;
243  if (true && ( (!(((int64(getBooleanOp())!=2)))) ) )
244  OP_Utils::evalOpParm(mySubtractChoices, node, "subtractchoices", time, 0);
245  else mySubtractChoices = 0;
246  if (true && ( (!(((int64(getBooleanOp())!=3)))) ) )
247  OP_Utils::evalOpParm(myShatterChoices, node, "shatterchoices", time, 0);
248  else myShatterChoices = 0;
249  if (true && ( (!(((int64(getBooleanOp())!=6)))) ) )
250  OP_Utils::evalOpParm(myOpenCurvesOnly, node, "opencurvesonly", time, 0);
251  else myOpenCurvesOnly = true;
252  if (true && ( (!(((int64(getBooleanOp())!=6)))) ) )
253  OP_Utils::evalOpParm(myGenerateAASeams, node, "generateaaseams", time, 0);
254  else myGenerateAASeams = true;
255  if (true && ( (!(((int64(getBooleanOp())!=6)))) ) )
256  OP_Utils::evalOpParm(myGenerateBBSeams, node, "generatebbseams", time, 0);
257  else myGenerateBBSeams = true;
258  if (true && ( (!(((int64(getBooleanOp())!=6)))) ) )
259  OP_Utils::evalOpParm(myGenerateABSeams, node, "generateabseams", time, 0);
260  else myGenerateABSeams = true;
261  if (true && ( (!(((int64(getBooleanOp())!=4)))) ) )
262  OP_Utils::evalOpParm(myWindingOp, node, "windingop", time, 0);
263  else myWindingOp = 0;
264  if (true && ( (!(((int64(getBooleanOp())!=4)))) ) )
265  OP_Utils::evalOpParm(myMergeNbrs, node, "mergenbrs", time, 0);
266  else myMergeNbrs = false;
267  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
268  OP_Utils::evalOpParm(myDetriangulate, node, "detriangulate", time, 0);
269  else myDetriangulate = 2;
270  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9))||((int64(getDetriangulate())!=2)))) ) )
271  OP_Utils::evalOpParm(myRemoveInlinePoints, node, "removeinlinepoints", time, 0);
272  else myRemoveInlinePoints = true;
273  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
274  OP_Utils::evalOpParm(myUniqueSeams, node, "uniqueseams", time, 0);
275  else myUniqueSeams = false;
276  if (true && ( (!(((int64(getBooleanOp())!=8)))) ) )
277  OP_Utils::evalOpParm(myUseAxAPolys, node, "useaxapolys", time, 0);
278  else myUseAxAPolys = false;
279  if (true && ( (!(((getUseAxAPolys()==0))||((int64(getBooleanOp())!=8)))) ) )
280  OP_Utils::evalOpParm(myAxAPolys, node, "axapolys", time, 0);
281  else myAxAPolys = "axapolys"_sh;
282  if (true && ( (!(((int64(getBooleanOp())!=8)))) ) )
283  OP_Utils::evalOpParm(myUseAxBPolys, node, "useaxbpolys", time, 0);
284  else myUseAxBPolys = false;
285  if (true && ( (!(((getUseAxBPolys()==0))||((int64(getBooleanOp())!=8)))) ) )
286  OP_Utils::evalOpParm(myAxBPolys, node, "axbpolys", time, 0);
287  else myAxBPolys = "axbpolys"_sh;
288  if (true && ( (!(((int64(getBooleanOp())!=8)))) ) )
289  OP_Utils::evalOpParm(myUseAxAList, node, "useaxalist", time, 0);
290  else myUseAxAList = false;
291  if (true && ( (!(((getUseAxAList()==0))||((int64(getBooleanOp())!=8)))) ) )
292  OP_Utils::evalOpParm(myAxAList, node, "axalist", time, 0);
293  else myAxAList = "axalist"_sh;
294  if (true && ( (!(((int64(getBooleanOp())!=8)))) ) )
295  OP_Utils::evalOpParm(myUseAxBList, node, "useaxblist", time, 0);
296  else myUseAxBList = false;
297  if (true && ( (!(((getUseAxBList()==0))||((int64(getBooleanOp())!=8)))) ) )
298  OP_Utils::evalOpParm(myAxBList, node, "axblist", time, 0);
299  else myAxBList = "axblist"_sh;
300  if (true && ( (!(((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9))||((int64(getBooleanOp())==6)))) ) )
301  OP_Utils::evalOpParm(myCollapseTinyEdges, node, "collapsetinyedges", time, 0);
302  else myCollapseTinyEdges = true;
303  if (true && ( (!(((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9))||((int64(getBooleanOp())==6))||((getCollapseTinyEdges()==0)))) ) )
304  OP_Utils::evalOpParm(myLengthThreshold, node, "lengththreshold", time, 0);
305  else myLengthThreshold = 0.00001;
306  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9))||((int64(getBSurface())==0)))) ) )
307  OP_Utils::evalOpParm(myUseAPolys, node, "useapolys", time, 0);
308  else myUseAPolys = false;
309  if (true && ( (!(((int64(getBSurface())==0))||((getUseAPolys()==0)))) ) )
310  OP_Utils::evalOpParm(myAPolys, node, "apolys", time, 0);
311  else myAPolys = "apolys"_sh;
312  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9))||((int64(getBSurface())==1)))) ) )
313  OP_Utils::evalOpParm(myUseAInsideB, node, "useainsideb", time, 0);
314  else myUseAInsideB = false;
315  if (true && ( (!(((int64(getBSurface())==1))||((getUseAInsideB()==0)))) ) )
316  OP_Utils::evalOpParm(myAInsideB, node, "ainsideb", time, 0);
317  else myAInsideB = "ainsideb"_sh;
318  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9))||((int64(getBSurface())==1)))) ) )
319  OP_Utils::evalOpParm(myUseAOutsideB, node, "useaoutsideb", time, 0);
320  else myUseAOutsideB = false;
321  if (true && ( (!(((int64(getBSurface())==1))||((getUseAOutsideB()==0)))) ) )
322  OP_Utils::evalOpParm(myAOutsideB, node, "aoutsideb", time, 0);
323  else myAOutsideB = "aoutsideb"_sh;
324  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9))||((int64(getASurface())==0)))) ) )
325  OP_Utils::evalOpParm(myUseBPolys, node, "usebpolys", time, 0);
326  else myUseBPolys = false;
327  if (true && ( (!(((getUseBPolys()==0))||((int64(getASurface())==0)))) ) )
328  OP_Utils::evalOpParm(myBPolys, node, "bpolys", time, 0);
329  else myBPolys = "bpolys"_sh;
330  if (true && ( (!(((int64(getASurface())==1))||((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
331  OP_Utils::evalOpParm(myUseBInsideA, node, "usebinsidea", time, 0);
332  else myUseBInsideA = false;
333  if (true && ( (!(((int64(getASurface())==1))||((getUseBInsideA()==0)))) ) )
334  OP_Utils::evalOpParm(myBInsideA, node, "binsidea", time, 0);
335  else myBInsideA = "binsidea"_sh;
336  if (true && ( (!(((int64(getASurface())==1))||((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
337  OP_Utils::evalOpParm(myUseBOutsideA, node, "useboutsidea", time, 0);
338  else myUseBOutsideA = false;
339  if (true && ( (!(((int64(getASurface())==1))||((getUseBOutsideA()==0)))) ) )
340  OP_Utils::evalOpParm(myBOutsideA, node, "boutsidea", time, 0);
341  else myBOutsideA = "boutsidea"_sh;
342  if (true && ( (!(((int64(getBooleanOp())==6))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
343  OP_Utils::evalOpParm(myUseABOverlap, node, "useaboverlap", time, 0);
344  else myUseABOverlap = false;
345  if (true && ( (!(((getUseABOverlap()==0)))) ) )
346  OP_Utils::evalOpParm(myABOverlap, node, "aboverlap", time, 0);
347  else myABOverlap = "aboverlap"_sh;
348  if (true && ( (!(((int64(getASurface())==1))||((int64(getBooleanOp())!=2)&&(int64(getBooleanOp())!=3))||((int64(getBooleanOp())==2)&&(int64(getSubtractChoices())!=2))||((int64(getBooleanOp())==3)&&(int64(getShatterChoices())==1)))) ) )
349  OP_Utils::evalOpParm(myUseAPieces, node, "useaonlypieces", time, 0);
350  else myUseAPieces = false;
351  if (true && ( (!(((int64(getASurface())==1))||((int64(getBooleanOp())!=2)&&(int64(getBooleanOp())!=3))||((int64(getBooleanOp())==2)&&(int64(getSubtractChoices())!=2))||((int64(getBooleanOp())==3)&&(int64(getShatterChoices())==1))||((getUseAPieces()==0)))) ) )
352  OP_Utils::evalOpParm(myAPieces, node, "aonlypieces", time, 0);
353  else myAPieces = "apieces"_sh;
354  if (true && ( (!(((int64(getBSurface())==1))||((int64(getBooleanOp())!=2)&&(int64(getBooleanOp())!=3))||((int64(getBooleanOp())==2)&&(int64(getSubtractChoices())!=2))||((int64(getBooleanOp())==3)&&(int64(getShatterChoices())==0)))) ) )
355  OP_Utils::evalOpParm(myUseBPieces, node, "usebonlypieces", time, 0);
356  else myUseBPieces = false;
357  if (true && ( (!(((int64(getBSurface())==1))||((int64(getBooleanOp())!=2)&&(int64(getBooleanOp())!=3))||((int64(getBooleanOp())==2)&&(int64(getSubtractChoices())!=2))||((int64(getBooleanOp())==3)&&(int64(getShatterChoices())==0))||((getUseBPieces()==0)))) ) )
358  OP_Utils::evalOpParm(myBPieces, node, "bonlypieces", time, 0);
359  else myBPieces = "bpieces"_sh;
360  if (true && ( (!(((int64(getBSurface())==1)&&(int64(getASurface())==1))||((int64(getBooleanOp())!=3)))) ) )
361  OP_Utils::evalOpParm(myUseABPieces, node, "useabpieces", time, 0);
362  else myUseABPieces = false;
363  if (true && ( (!(((int64(getBSurface())==1)&&(int64(getASurface())==1))||((int64(getBooleanOp())!=3))||((getUseABPieces()==0)))) ) )
364  OP_Utils::evalOpParm(myABPieces, node, "abpieces", time, 0);
365  else myABPieces = "abpieces"_sh;
366  if (true && ( (!(((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
367  OP_Utils::evalOpParm(myUseAASeamEdges, node, "useaaseamedges", time, 0);
368  else myUseAASeamEdges = false;
369  if (true && ( (!(((getUseAASeamEdges()==0))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
370  OP_Utils::evalOpParm(myAASeamEdges, node, "aaseamedges", time, 0);
371  else myAASeamEdges = "aseams"_sh;
372  if (true && ( (!(((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
373  OP_Utils::evalOpParm(myUseBBSeamEdges, node, "usebbseamedges", time, 0);
374  else myUseBBSeamEdges = false;
375  if (true && ( (!(((getUseBBSeamEdges()==0))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
376  OP_Utils::evalOpParm(myBBSeamEdges, node, "bbseamedges", time, 0);
377  else myBBSeamEdges = "bseams"_sh;
378  if (true && ( (!(((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
379  OP_Utils::evalOpParm(myUseABSeamEdges, node, "useabseamedges", time, 0);
380  else myUseABSeamEdges = false;
381  if (true && ( (!(((getUseABSeamEdges()==0))||((int64(getBooleanOp())==8))||((int64(getBooleanOp())==9)))) ) )
382  OP_Utils::evalOpParm(myABSeamEdges, node, "abseamedges", time, 0);
383  else myABSeamEdges = "abseams"_sh;
384  if (true && ( (!(((int64(getBooleanOp())!=4))||((int64(getWindingOp())==1)))) ) )
385  OP_Utils::evalOpParm(myDepthInA, node, "adepth", time, 0);
386  else myDepthInA = UT_Vector2I(1,1000);
387  if (true && ( (!(((int64(getBooleanOp())!=4))||((int64(getWindingOp())==0)))) ) )
388  OP_Utils::evalOpParm(myDepthInB, node, "bdepth", time, 0);
389  else myDepthInB = UT_Vector2I(1,1000);
390 
391  }
392 
393 
394  virtual void loadFromOpSubclass(const LoadParms &loadparms)
395  {
396  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
397  }
398 
399 
400  virtual void copyFrom(const SOP_NodeParms *src)
401  {
402  *this = *((const SOP_BooleanParms *)src);
403  }
404 
405  template <typename T>
406  void
407  doGetParmValue(exint idx, T &value) const
408  {
409  switch (idx)
410  {
411  case 0:
412  coerceValue(value, myGroupA);
413  break;
414  case 1:
415  coerceValue(value, myASurface);
416  break;
417  case 2:
418  coerceValue(value, myResolveA);
419  break;
420  case 3:
421  coerceValue(value, myGroupB);
422  break;
423  case 4:
424  coerceValue(value, myBSurface);
425  break;
426  case 5:
427  coerceValue(value, myResolveB);
428  break;
429  case 6:
430  coerceValue(value, myBooleanOp);
431  break;
432  case 7:
433  coerceValue(value, mySubtractChoices);
434  break;
435  case 8:
436  coerceValue(value, myShatterChoices);
437  break;
438  case 9:
439  coerceValue(value, myOpenCurvesOnly);
440  break;
441  case 10:
442  coerceValue(value, myGenerateAASeams);
443  break;
444  case 11:
445  coerceValue(value, myGenerateBBSeams);
446  break;
447  case 12:
448  coerceValue(value, myGenerateABSeams);
449  break;
450  case 13:
451  coerceValue(value, myWindingOp);
452  break;
453  case 14:
454  coerceValue(value, myMergeNbrs);
455  break;
456  case 15:
457  coerceValue(value, myDetriangulate);
458  break;
459  case 16:
460  coerceValue(value, myRemoveInlinePoints);
461  break;
462  case 17:
463  coerceValue(value, myUniqueSeams);
464  break;
465  case 18:
466  coerceValue(value, myUseAxAPolys);
467  break;
468  case 19:
469  coerceValue(value, myAxAPolys);
470  break;
471  case 20:
472  coerceValue(value, myUseAxBPolys);
473  break;
474  case 21:
475  coerceValue(value, myAxBPolys);
476  break;
477  case 22:
478  coerceValue(value, myUseAxAList);
479  break;
480  case 23:
481  coerceValue(value, myAxAList);
482  break;
483  case 24:
484  coerceValue(value, myUseAxBList);
485  break;
486  case 25:
487  coerceValue(value, myAxBList);
488  break;
489  case 26:
490  coerceValue(value, myCollapseTinyEdges);
491  break;
492  case 27:
493  coerceValue(value, myLengthThreshold);
494  break;
495  case 28:
496  coerceValue(value, myUseAPolys);
497  break;
498  case 29:
499  coerceValue(value, myAPolys);
500  break;
501  case 30:
502  coerceValue(value, myUseAInsideB);
503  break;
504  case 31:
505  coerceValue(value, myAInsideB);
506  break;
507  case 32:
508  coerceValue(value, myUseAOutsideB);
509  break;
510  case 33:
511  coerceValue(value, myAOutsideB);
512  break;
513  case 34:
514  coerceValue(value, myUseBPolys);
515  break;
516  case 35:
517  coerceValue(value, myBPolys);
518  break;
519  case 36:
520  coerceValue(value, myUseBInsideA);
521  break;
522  case 37:
523  coerceValue(value, myBInsideA);
524  break;
525  case 38:
526  coerceValue(value, myUseBOutsideA);
527  break;
528  case 39:
529  coerceValue(value, myBOutsideA);
530  break;
531  case 40:
532  coerceValue(value, myUseABOverlap);
533  break;
534  case 41:
535  coerceValue(value, myABOverlap);
536  break;
537  case 42:
538  coerceValue(value, myUseAPieces);
539  break;
540  case 43:
541  coerceValue(value, myAPieces);
542  break;
543  case 44:
544  coerceValue(value, myUseBPieces);
545  break;
546  case 45:
547  coerceValue(value, myBPieces);
548  break;
549  case 46:
550  coerceValue(value, myUseABPieces);
551  break;
552  case 47:
553  coerceValue(value, myABPieces);
554  break;
555  case 48:
556  coerceValue(value, myUseAASeamEdges);
557  break;
558  case 49:
559  coerceValue(value, myAASeamEdges);
560  break;
561  case 50:
562  coerceValue(value, myUseBBSeamEdges);
563  break;
564  case 51:
565  coerceValue(value, myBBSeamEdges);
566  break;
567  case 52:
568  coerceValue(value, myUseABSeamEdges);
569  break;
570  case 53:
571  coerceValue(value, myABSeamEdges);
572  break;
573  case 54:
574  coerceValue(value, myDepthInA);
575  break;
576  case 55:
577  coerceValue(value, myDepthInB);
578  break;
579 
580  }
581  }
582 
583  void getParmValue(exint idx, exint &value) const
584  { doGetParmValue(idx, value); }
585  void getParmValue(exint idx, fpreal &value) const
586  { doGetParmValue(idx, value); }
588  { doGetParmValue(idx, value); }
590  { doGetParmValue(idx, value); }
592  { doGetParmValue(idx, value); }
594  { doGetParmValue(idx, value); }
596  { doGetParmValue(idx, value); }
598  { doGetParmValue(idx, value); }
600  { doGetParmValue(idx, value); }
602  { doGetParmValue(idx, value); }
604  { doGetParmValue(idx, value); }
605 
606  template <typename T>
607  void
608  doSetParmValue(exint idx, const T &value)
609  {
610  switch (idx)
611  {
612  case 0:
613  coerceValue(myGroupA, value);
614  break;
615  case 1:
616  coerceValue(myASurface, value);
617  break;
618  case 2:
619  coerceValue(myResolveA, value);
620  break;
621  case 3:
622  coerceValue(myGroupB, value);
623  break;
624  case 4:
625  coerceValue(myBSurface, value);
626  break;
627  case 5:
628  coerceValue(myResolveB, value);
629  break;
630  case 6:
631  coerceValue(myBooleanOp, value);
632  break;
633  case 7:
634  coerceValue(mySubtractChoices, value);
635  break;
636  case 8:
637  coerceValue(myShatterChoices, value);
638  break;
639  case 9:
640  coerceValue(myOpenCurvesOnly, value);
641  break;
642  case 10:
643  coerceValue(myGenerateAASeams, value);
644  break;
645  case 11:
646  coerceValue(myGenerateBBSeams, value);
647  break;
648  case 12:
649  coerceValue(myGenerateABSeams, value);
650  break;
651  case 13:
652  coerceValue(myWindingOp, value);
653  break;
654  case 14:
655  coerceValue(myMergeNbrs, value);
656  break;
657  case 15:
658  coerceValue(myDetriangulate, value);
659  break;
660  case 16:
661  coerceValue(myRemoveInlinePoints, value);
662  break;
663  case 17:
664  coerceValue(myUniqueSeams, value);
665  break;
666  case 18:
667  coerceValue(myUseAxAPolys, value);
668  break;
669  case 19:
670  coerceValue(myAxAPolys, value);
671  break;
672  case 20:
673  coerceValue(myUseAxBPolys, value);
674  break;
675  case 21:
676  coerceValue(myAxBPolys, value);
677  break;
678  case 22:
679  coerceValue(myUseAxAList, value);
680  break;
681  case 23:
682  coerceValue(myAxAList, value);
683  break;
684  case 24:
685  coerceValue(myUseAxBList, value);
686  break;
687  case 25:
688  coerceValue(myAxBList, value);
689  break;
690  case 26:
691  coerceValue(myCollapseTinyEdges, value);
692  break;
693  case 27:
694  coerceValue(myLengthThreshold, value);
695  break;
696  case 28:
697  coerceValue(myUseAPolys, value);
698  break;
699  case 29:
700  coerceValue(myAPolys, value);
701  break;
702  case 30:
703  coerceValue(myUseAInsideB, value);
704  break;
705  case 31:
706  coerceValue(myAInsideB, value);
707  break;
708  case 32:
709  coerceValue(myUseAOutsideB, value);
710  break;
711  case 33:
712  coerceValue(myAOutsideB, value);
713  break;
714  case 34:
715  coerceValue(myUseBPolys, value);
716  break;
717  case 35:
718  coerceValue(myBPolys, value);
719  break;
720  case 36:
721  coerceValue(myUseBInsideA, value);
722  break;
723  case 37:
724  coerceValue(myBInsideA, value);
725  break;
726  case 38:
727  coerceValue(myUseBOutsideA, value);
728  break;
729  case 39:
730  coerceValue(myBOutsideA, value);
731  break;
732  case 40:
733  coerceValue(myUseABOverlap, value);
734  break;
735  case 41:
736  coerceValue(myABOverlap, value);
737  break;
738  case 42:
739  coerceValue(myUseAPieces, value);
740  break;
741  case 43:
742  coerceValue(myAPieces, value);
743  break;
744  case 44:
745  coerceValue(myUseBPieces, value);
746  break;
747  case 45:
748  coerceValue(myBPieces, value);
749  break;
750  case 46:
751  coerceValue(myUseABPieces, value);
752  break;
753  case 47:
754  coerceValue(myABPieces, value);
755  break;
756  case 48:
757  coerceValue(myUseAASeamEdges, value);
758  break;
759  case 49:
760  coerceValue(myAASeamEdges, value);
761  break;
762  case 50:
763  coerceValue(myUseBBSeamEdges, value);
764  break;
765  case 51:
766  coerceValue(myBBSeamEdges, value);
767  break;
768  case 52:
769  coerceValue(myUseABSeamEdges, value);
770  break;
771  case 53:
772  coerceValue(myABSeamEdges, value);
773  break;
774  case 54:
775  coerceValue(myDepthInA, value);
776  break;
777  case 55:
778  coerceValue(myDepthInB, value);
779  break;
780 
781  }
782  }
783 
784  void setParmValue(exint idx, const exint &value)
785  { doSetParmValue(idx, value); }
786  void setParmValue(exint idx, const fpreal &value)
787  { doSetParmValue(idx, value); }
788  void setParmValue(exint idx, const UT_Vector2D &value)
789  { doSetParmValue(idx, value); }
790  void setParmValue(exint idx, const UT_Vector3D &value)
791  { doSetParmValue(idx, value); }
792  void setParmValue(exint idx, const UT_Vector4D &value)
793  { doSetParmValue(idx, value); }
794  void setParmValue(exint idx, const UT_Matrix2D &value)
795  { doSetParmValue(idx, value); }
796  void setParmValue(exint idx, const UT_Matrix3D &value)
797  { doSetParmValue(idx, value); }
798  void setParmValue(exint idx, const UT_Matrix4D &value)
799  { doSetParmValue(idx, value); }
801  { doSetParmValue(idx, value); }
803  { doSetParmValue(idx, value); }
805  { doSetParmValue(idx, value); }
806 
807  virtual exint getNumParms() const
808  {
809  return 56;
810  }
811 
812  virtual const char *getParmName(exint fieldnum) const
813  {
814  switch (fieldnum)
815  {
816  case 0:
817  return "agroup";
818  case 1:
819  return "asurface";
820  case 2:
821  return "resolvea";
822  case 3:
823  return "bgroup";
824  case 4:
825  return "bsurface";
826  case 5:
827  return "resolveb";
828  case 6:
829  return "booleanop";
830  case 7:
831  return "subtractchoices";
832  case 8:
833  return "shatterchoices";
834  case 9:
835  return "opencurvesonly";
836  case 10:
837  return "generateaaseams";
838  case 11:
839  return "generatebbseams";
840  case 12:
841  return "generateabseams";
842  case 13:
843  return "windingop";
844  case 14:
845  return "mergenbrs";
846  case 15:
847  return "detriangulate";
848  case 16:
849  return "removeinlinepoints";
850  case 17:
851  return "uniqueseams";
852  case 18:
853  return "useaxapolys";
854  case 19:
855  return "axapolys";
856  case 20:
857  return "useaxbpolys";
858  case 21:
859  return "axbpolys";
860  case 22:
861  return "useaxalist";
862  case 23:
863  return "axalist";
864  case 24:
865  return "useaxblist";
866  case 25:
867  return "axblist";
868  case 26:
869  return "collapsetinyedges";
870  case 27:
871  return "lengththreshold";
872  case 28:
873  return "useapolys";
874  case 29:
875  return "apolys";
876  case 30:
877  return "useainsideb";
878  case 31:
879  return "ainsideb";
880  case 32:
881  return "useaoutsideb";
882  case 33:
883  return "aoutsideb";
884  case 34:
885  return "usebpolys";
886  case 35:
887  return "bpolys";
888  case 36:
889  return "usebinsidea";
890  case 37:
891  return "binsidea";
892  case 38:
893  return "useboutsidea";
894  case 39:
895  return "boutsidea";
896  case 40:
897  return "useaboverlap";
898  case 41:
899  return "aboverlap";
900  case 42:
901  return "useaonlypieces";
902  case 43:
903  return "aonlypieces";
904  case 44:
905  return "usebonlypieces";
906  case 45:
907  return "bonlypieces";
908  case 46:
909  return "useabpieces";
910  case 47:
911  return "abpieces";
912  case 48:
913  return "useaaseamedges";
914  case 49:
915  return "aaseamedges";
916  case 50:
917  return "usebbseamedges";
918  case 51:
919  return "bbseamedges";
920  case 52:
921  return "useabseamedges";
922  case 53:
923  return "abseamedges";
924  case 54:
925  return "adepth";
926  case 55:
927  return "bdepth";
928 
929  }
930  return 0;
931  }
932 
933  virtual ParmType getParmType(exint fieldnum) const
934  {
935  switch (fieldnum)
936  {
937  case 0:
938  return PARM_STRING;
939  case 1:
940  return PARM_INTEGER;
941  case 2:
942  return PARM_INTEGER;
943  case 3:
944  return PARM_STRING;
945  case 4:
946  return PARM_INTEGER;
947  case 5:
948  return PARM_INTEGER;
949  case 6:
950  return PARM_INTEGER;
951  case 7:
952  return PARM_INTEGER;
953  case 8:
954  return PARM_INTEGER;
955  case 9:
956  return PARM_INTEGER;
957  case 10:
958  return PARM_INTEGER;
959  case 11:
960  return PARM_INTEGER;
961  case 12:
962  return PARM_INTEGER;
963  case 13:
964  return PARM_INTEGER;
965  case 14:
966  return PARM_INTEGER;
967  case 15:
968  return PARM_INTEGER;
969  case 16:
970  return PARM_INTEGER;
971  case 17:
972  return PARM_INTEGER;
973  case 18:
974  return PARM_INTEGER;
975  case 19:
976  return PARM_STRING;
977  case 20:
978  return PARM_INTEGER;
979  case 21:
980  return PARM_STRING;
981  case 22:
982  return PARM_INTEGER;
983  case 23:
984  return PARM_STRING;
985  case 24:
986  return PARM_INTEGER;
987  case 25:
988  return PARM_STRING;
989  case 26:
990  return PARM_INTEGER;
991  case 27:
992  return PARM_FLOAT;
993  case 28:
994  return PARM_INTEGER;
995  case 29:
996  return PARM_STRING;
997  case 30:
998  return PARM_INTEGER;
999  case 31:
1000  return PARM_STRING;
1001  case 32:
1002  return PARM_INTEGER;
1003  case 33:
1004  return PARM_STRING;
1005  case 34:
1006  return PARM_INTEGER;
1007  case 35:
1008  return PARM_STRING;
1009  case 36:
1010  return PARM_INTEGER;
1011  case 37:
1012  return PARM_STRING;
1013  case 38:
1014  return PARM_INTEGER;
1015  case 39:
1016  return PARM_STRING;
1017  case 40:
1018  return PARM_INTEGER;
1019  case 41:
1020  return PARM_STRING;
1021  case 42:
1022  return PARM_INTEGER;
1023  case 43:
1024  return PARM_STRING;
1025  case 44:
1026  return PARM_INTEGER;
1027  case 45:
1028  return PARM_STRING;
1029  case 46:
1030  return PARM_INTEGER;
1031  case 47:
1032  return PARM_STRING;
1033  case 48:
1034  return PARM_INTEGER;
1035  case 49:
1036  return PARM_STRING;
1037  case 50:
1038  return PARM_INTEGER;
1039  case 51:
1040  return PARM_STRING;
1041  case 52:
1042  return PARM_INTEGER;
1043  case 53:
1044  return PARM_STRING;
1045  case 54:
1046  return PARM_VECTOR2;
1047  case 55:
1048  return PARM_VECTOR2;
1049 
1050  }
1051  return PARM_UNSUPPORTED;
1052  }
1053 
1054  // Boiler plate to load individual types.
1055  static void loadData(UT_IStream &is, int64 &v)
1056  { is.bread(&v, 1); }
1057  static void loadData(UT_IStream &is, bool &v)
1058  { int64 iv; is.bread(&iv, 1); v = iv; }
1059  static void loadData(UT_IStream &is, fpreal64 &v)
1060  { is.bread<fpreal64>(&v, 1); }
1061  static void loadData(UT_IStream &is, UT_Vector2D &v)
1062  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
1063  static void loadData(UT_IStream &is, UT_Vector3D &v)
1064  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1065  is.bread<fpreal64>(&v.z(), 1); }
1066  static void loadData(UT_IStream &is, UT_Vector4D &v)
1067  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1068  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
1069  static void loadData(UT_IStream &is, UT_Matrix2D &v)
1070  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
1071  static void loadData(UT_IStream &is, UT_Matrix3D &v)
1072  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
1073  static void loadData(UT_IStream &is, UT_Matrix4D &v)
1074  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
1075  static void loadData(UT_IStream &is, UT_Vector2I &v)
1076  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
1077  static void loadData(UT_IStream &is, UT_Vector3I &v)
1078  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1079  is.bread<int64>(&v.z(), 1); }
1080  static void loadData(UT_IStream &is, UT_Vector4I &v)
1081  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1082  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
1084  { is.bread(v); }
1086  { UT_StringHolder rampdata;
1087  loadData(is, rampdata);
1088  if (rampdata.isstring())
1089  {
1090  v.reset(new UT_Ramp());
1091  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
1092  v->load(istr);
1093  }
1094  else v.reset();
1095  }
1098  loadData(is, data);
1099  if (data.isstring())
1100  {
1101  // Find the data type.
1102  char *colon = UT_StringWrap(data).findChar(':');
1103  if (colon)
1104  {
1105  int typelen = colon - data.buffer();
1107  type.strncpy(data.buffer(), typelen);
1108  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1109 
1110  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1111  }
1112  }
1113  else v.reset();
1114  }
1115 
1116  static void saveData(std::ostream &os, int64 v)
1117  { UTwrite(os, &v); }
1118  static void saveData(std::ostream &os, bool v)
1119  { int64 iv = v; UTwrite(os, &iv); }
1120  static void saveData(std::ostream &os, fpreal64 v)
1121  { UTwrite<fpreal64>(os, &v); }
1122  static void saveData(std::ostream &os, UT_Vector2D v)
1123  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1124  static void saveData(std::ostream &os, UT_Vector3D v)
1125  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1126  UTwrite<fpreal64>(os, &v.z()); }
1127  static void saveData(std::ostream &os, UT_Vector4D v)
1128  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1129  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1130  static void saveData(std::ostream &os, UT_Matrix2D v)
1131  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1132  static void saveData(std::ostream &os, UT_Matrix3D v)
1133  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1134  static void saveData(std::ostream &os, UT_Matrix4D v)
1135  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1136  static void saveData(std::ostream &os, UT_StringHolder s)
1137  { UT_StringWrap(s).saveBinary(os); }
1138  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1139  { UT_StringHolder result;
1140  UT_OStringStream ostr;
1141  if (s) s->save(ostr);
1142  result = ostr.str();
1143  saveData(os, result);
1144  }
1145  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1146  { UT_StringHolder result;
1147  UT_OStringStream ostr;
1148  if (s)
1149  {
1150  ostr << s->getDataTypeToken();
1151  ostr << ":";
1152  s->saveBinary(ostr);
1153  }
1154  result = ostr.str();
1155  saveData(os, result);
1156  }
1157 
1158 
1159  void save(std::ostream &os) const
1160  {
1161  int32 v = version();
1162  UTwrite(os, &v);
1163  saveData(os, myGroupA);
1164  saveData(os, myASurface);
1165  saveData(os, myResolveA);
1166  saveData(os, myGroupB);
1167  saveData(os, myBSurface);
1168  saveData(os, myResolveB);
1169  saveData(os, myBooleanOp);
1170  saveData(os, mySubtractChoices);
1171  saveData(os, myShatterChoices);
1172  saveData(os, myOpenCurvesOnly);
1173  saveData(os, myGenerateAASeams);
1174  saveData(os, myGenerateBBSeams);
1175  saveData(os, myGenerateABSeams);
1176  saveData(os, myWindingOp);
1177  saveData(os, myMergeNbrs);
1178  saveData(os, myDetriangulate);
1179  saveData(os, myRemoveInlinePoints);
1180  saveData(os, myUniqueSeams);
1181  saveData(os, myUseAxAPolys);
1182  saveData(os, myAxAPolys);
1183  saveData(os, myUseAxBPolys);
1184  saveData(os, myAxBPolys);
1185  saveData(os, myUseAxAList);
1186  saveData(os, myAxAList);
1187  saveData(os, myUseAxBList);
1188  saveData(os, myAxBList);
1189  saveData(os, myCollapseTinyEdges);
1190  saveData(os, myLengthThreshold);
1191  saveData(os, myUseAPolys);
1192  saveData(os, myAPolys);
1193  saveData(os, myUseAInsideB);
1194  saveData(os, myAInsideB);
1195  saveData(os, myUseAOutsideB);
1196  saveData(os, myAOutsideB);
1197  saveData(os, myUseBPolys);
1198  saveData(os, myBPolys);
1199  saveData(os, myUseBInsideA);
1200  saveData(os, myBInsideA);
1201  saveData(os, myUseBOutsideA);
1202  saveData(os, myBOutsideA);
1203  saveData(os, myUseABOverlap);
1204  saveData(os, myABOverlap);
1205  saveData(os, myUseAPieces);
1206  saveData(os, myAPieces);
1207  saveData(os, myUseBPieces);
1208  saveData(os, myBPieces);
1209  saveData(os, myUseABPieces);
1210  saveData(os, myABPieces);
1211  saveData(os, myUseAASeamEdges);
1212  saveData(os, myAASeamEdges);
1213  saveData(os, myUseBBSeamEdges);
1214  saveData(os, myBBSeamEdges);
1215  saveData(os, myUseABSeamEdges);
1216  saveData(os, myABSeamEdges);
1217  saveData(os, myDepthInA);
1218  saveData(os, myDepthInB);
1219 
1220  }
1221 
1222  bool load(UT_IStream &is)
1223  {
1224  int32 v;
1225  is.bread(&v, 1);
1226  if (version() != v)
1227  {
1228  // Fail incompatible versions
1229  return false;
1230  }
1231  loadData(is, myGroupA);
1232  loadData(is, myASurface);
1233  loadData(is, myResolveA);
1234  loadData(is, myGroupB);
1235  loadData(is, myBSurface);
1236  loadData(is, myResolveB);
1237  loadData(is, myBooleanOp);
1238  loadData(is, mySubtractChoices);
1239  loadData(is, myShatterChoices);
1240  loadData(is, myOpenCurvesOnly);
1241  loadData(is, myGenerateAASeams);
1242  loadData(is, myGenerateBBSeams);
1243  loadData(is, myGenerateABSeams);
1244  loadData(is, myWindingOp);
1245  loadData(is, myMergeNbrs);
1246  loadData(is, myDetriangulate);
1247  loadData(is, myRemoveInlinePoints);
1248  loadData(is, myUniqueSeams);
1249  loadData(is, myUseAxAPolys);
1250  loadData(is, myAxAPolys);
1251  loadData(is, myUseAxBPolys);
1252  loadData(is, myAxBPolys);
1253  loadData(is, myUseAxAList);
1254  loadData(is, myAxAList);
1255  loadData(is, myUseAxBList);
1256  loadData(is, myAxBList);
1257  loadData(is, myCollapseTinyEdges);
1258  loadData(is, myLengthThreshold);
1259  loadData(is, myUseAPolys);
1260  loadData(is, myAPolys);
1261  loadData(is, myUseAInsideB);
1262  loadData(is, myAInsideB);
1263  loadData(is, myUseAOutsideB);
1264  loadData(is, myAOutsideB);
1265  loadData(is, myUseBPolys);
1266  loadData(is, myBPolys);
1267  loadData(is, myUseBInsideA);
1268  loadData(is, myBInsideA);
1269  loadData(is, myUseBOutsideA);
1270  loadData(is, myBOutsideA);
1271  loadData(is, myUseABOverlap);
1272  loadData(is, myABOverlap);
1273  loadData(is, myUseAPieces);
1274  loadData(is, myAPieces);
1275  loadData(is, myUseBPieces);
1276  loadData(is, myBPieces);
1277  loadData(is, myUseABPieces);
1278  loadData(is, myABPieces);
1279  loadData(is, myUseAASeamEdges);
1280  loadData(is, myAASeamEdges);
1281  loadData(is, myUseBBSeamEdges);
1282  loadData(is, myBBSeamEdges);
1283  loadData(is, myUseABSeamEdges);
1284  loadData(is, myABSeamEdges);
1285  loadData(is, myDepthInA);
1286  loadData(is, myDepthInB);
1287 
1288  return true;
1289  }
1290 
1291  const UT_StringHolder & getGroupA() const { return myGroupA; }
1292  void setGroupA(const UT_StringHolder & val) { myGroupA = val; }
1294  {
1295  SOP_Node *thissop = cookparms.getNode();
1296  if (!thissop) return getGroupA();
1297  UT_StringHolder result;
1298  OP_Utils::evalOpParm(result, thissop, "agroup", cookparms.getCookTime(), 0);
1299  return result;
1300  }
1301  ASurface getASurface() const { return ASurface(myASurface); }
1302  void setASurface(ASurface val) { myASurface = int64(val); }
1304  {
1305  SOP_Node *thissop = cookparms.getNode();
1306  if (!thissop) return getASurface();
1307  int64 result;
1308  OP_Utils::evalOpParm(result, thissop, "asurface", cookparms.getCookTime(), 0);
1309  return ASurface(result);
1310  }
1311  bool getResolveA() const { return myResolveA; }
1312  void setResolveA(bool val) { myResolveA = val; }
1313  bool opResolveA(const SOP_NodeVerb::CookParms &cookparms) const
1314  {
1315  SOP_Node *thissop = cookparms.getNode();
1316  if (!thissop) return getResolveA();
1317  bool result;
1318  OP_Utils::evalOpParm(result, thissop, "resolvea", cookparms.getCookTime(), 0);
1319  return result;
1320  }
1321  const UT_StringHolder & getGroupB() const { return myGroupB; }
1322  void setGroupB(const UT_StringHolder & val) { myGroupB = val; }
1324  {
1325  SOP_Node *thissop = cookparms.getNode();
1326  if (!thissop) return getGroupB();
1327  UT_StringHolder result;
1328  OP_Utils::evalOpParm(result, thissop, "bgroup", cookparms.getCookTime(), 0);
1329  return result;
1330  }
1331  BSurface getBSurface() const { return BSurface(myBSurface); }
1332  void setBSurface(BSurface val) { myBSurface = int64(val); }
1334  {
1335  SOP_Node *thissop = cookparms.getNode();
1336  if (!thissop) return getBSurface();
1337  int64 result;
1338  OP_Utils::evalOpParm(result, thissop, "bsurface", cookparms.getCookTime(), 0);
1339  return BSurface(result);
1340  }
1341  bool getResolveB() const { return myResolveB; }
1342  void setResolveB(bool val) { myResolveB = val; }
1343  bool opResolveB(const SOP_NodeVerb::CookParms &cookparms) const
1344  {
1345  SOP_Node *thissop = cookparms.getNode();
1346  if (!thissop) return getResolveB();
1347  bool result;
1348  OP_Utils::evalOpParm(result, thissop, "resolveb", cookparms.getCookTime(), 0);
1349  return result;
1350  }
1351  BooleanOp getBooleanOp() const { return BooleanOp(myBooleanOp); }
1352  void setBooleanOp(BooleanOp val) { myBooleanOp = int64(val); }
1354  {
1355  SOP_Node *thissop = cookparms.getNode();
1356  if (!thissop) return getBooleanOp();
1357  int64 result;
1358  OP_Utils::evalOpParm(result, thissop, "booleanop", cookparms.getCookTime(), 0);
1359  return BooleanOp(result);
1360  }
1361  SubtractChoices getSubtractChoices() const { return SubtractChoices(mySubtractChoices); }
1362  void setSubtractChoices(SubtractChoices val) { mySubtractChoices = int64(val); }
1364  {
1365  SOP_Node *thissop = cookparms.getNode();
1366  if (!thissop) return getSubtractChoices();
1367  int64 result;
1368  OP_Utils::evalOpParm(result, thissop, "subtractchoices", cookparms.getCookTime(), 0);
1369  return SubtractChoices(result);
1370  }
1371  ShatterChoices getShatterChoices() const { return ShatterChoices(myShatterChoices); }
1372  void setShatterChoices(ShatterChoices val) { myShatterChoices = int64(val); }
1374  {
1375  SOP_Node *thissop = cookparms.getNode();
1376  if (!thissop) return getShatterChoices();
1377  int64 result;
1378  OP_Utils::evalOpParm(result, thissop, "shatterchoices", cookparms.getCookTime(), 0);
1379  return ShatterChoices(result);
1380  }
1381  bool getOpenCurvesOnly() const { return myOpenCurvesOnly; }
1382  void setOpenCurvesOnly(bool val) { myOpenCurvesOnly = val; }
1383  bool opOpenCurvesOnly(const SOP_NodeVerb::CookParms &cookparms) const
1384  {
1385  SOP_Node *thissop = cookparms.getNode();
1386  if (!thissop) return getOpenCurvesOnly();
1387  bool result;
1388  OP_Utils::evalOpParm(result, thissop, "opencurvesonly", cookparms.getCookTime(), 0);
1389  return result;
1390  }
1391  bool getGenerateAASeams() const { return myGenerateAASeams; }
1392  void setGenerateAASeams(bool val) { myGenerateAASeams = val; }
1393  bool opGenerateAASeams(const SOP_NodeVerb::CookParms &cookparms) const
1394  {
1395  SOP_Node *thissop = cookparms.getNode();
1396  if (!thissop) return getGenerateAASeams();
1397  bool result;
1398  OP_Utils::evalOpParm(result, thissop, "generateaaseams", cookparms.getCookTime(), 0);
1399  return result;
1400  }
1401  bool getGenerateBBSeams() const { return myGenerateBBSeams; }
1402  void setGenerateBBSeams(bool val) { myGenerateBBSeams = val; }
1403  bool opGenerateBBSeams(const SOP_NodeVerb::CookParms &cookparms) const
1404  {
1405  SOP_Node *thissop = cookparms.getNode();
1406  if (!thissop) return getGenerateBBSeams();
1407  bool result;
1408  OP_Utils::evalOpParm(result, thissop, "generatebbseams", cookparms.getCookTime(), 0);
1409  return result;
1410  }
1411  bool getGenerateABSeams() const { return myGenerateABSeams; }
1412  void setGenerateABSeams(bool val) { myGenerateABSeams = val; }
1413  bool opGenerateABSeams(const SOP_NodeVerb::CookParms &cookparms) const
1414  {
1415  SOP_Node *thissop = cookparms.getNode();
1416  if (!thissop) return getGenerateABSeams();
1417  bool result;
1418  OP_Utils::evalOpParm(result, thissop, "generateabseams", cookparms.getCookTime(), 0);
1419  return result;
1420  }
1421  WindingOp getWindingOp() const { return WindingOp(myWindingOp); }
1422  void setWindingOp(WindingOp val) { myWindingOp = int64(val); }
1424  {
1425  SOP_Node *thissop = cookparms.getNode();
1426  if (!thissop) return getWindingOp();
1427  int64 result;
1428  OP_Utils::evalOpParm(result, thissop, "windingop", cookparms.getCookTime(), 0);
1429  return WindingOp(result);
1430  }
1431  bool getMergeNbrs() const { return myMergeNbrs; }
1432  void setMergeNbrs(bool val) { myMergeNbrs = val; }
1433  bool opMergeNbrs(const SOP_NodeVerb::CookParms &cookparms) const
1434  {
1435  SOP_Node *thissop = cookparms.getNode();
1436  if (!thissop) return getMergeNbrs();
1437  bool result;
1438  OP_Utils::evalOpParm(result, thissop, "mergenbrs", cookparms.getCookTime(), 0);
1439  return result;
1440  }
1441  Detriangulate getDetriangulate() const { return Detriangulate(myDetriangulate); }
1442  void setDetriangulate(Detriangulate val) { myDetriangulate = int64(val); }
1444  {
1445  SOP_Node *thissop = cookparms.getNode();
1446  if (!thissop) return getDetriangulate();
1447  int64 result;
1448  OP_Utils::evalOpParm(result, thissop, "detriangulate", cookparms.getCookTime(), 0);
1449  return Detriangulate(result);
1450  }
1451  bool getRemoveInlinePoints() const { return myRemoveInlinePoints; }
1452  void setRemoveInlinePoints(bool val) { myRemoveInlinePoints = val; }
1453  bool opRemoveInlinePoints(const SOP_NodeVerb::CookParms &cookparms) const
1454  {
1455  SOP_Node *thissop = cookparms.getNode();
1456  if (!thissop) return getRemoveInlinePoints();
1457  bool result;
1458  OP_Utils::evalOpParm(result, thissop, "removeinlinepoints", cookparms.getCookTime(), 0);
1459  return result;
1460  }
1461  bool getUniqueSeams() const { return myUniqueSeams; }
1462  void setUniqueSeams(bool val) { myUniqueSeams = val; }
1463  bool opUniqueSeams(const SOP_NodeVerb::CookParms &cookparms) const
1464  {
1465  SOP_Node *thissop = cookparms.getNode();
1466  if (!thissop) return getUniqueSeams();
1467  bool result;
1468  OP_Utils::evalOpParm(result, thissop, "uniqueseams", cookparms.getCookTime(), 0);
1469  return result;
1470  }
1471  bool getUseAxAPolys() const { return myUseAxAPolys; }
1472  void setUseAxAPolys(bool val) { myUseAxAPolys = val; }
1473  bool opUseAxAPolys(const SOP_NodeVerb::CookParms &cookparms) const
1474  {
1475  SOP_Node *thissop = cookparms.getNode();
1476  if (!thissop) return getUseAxAPolys();
1477  bool result;
1478  OP_Utils::evalOpParm(result, thissop, "useaxapolys", cookparms.getCookTime(), 0);
1479  return result;
1480  }
1481  const UT_StringHolder & getAxAPolys() const { return myAxAPolys; }
1482  void setAxAPolys(const UT_StringHolder & val) { myAxAPolys = val; }
1484  {
1485  SOP_Node *thissop = cookparms.getNode();
1486  if (!thissop) return getAxAPolys();
1487  UT_StringHolder result;
1488  OP_Utils::evalOpParm(result, thissop, "axapolys", cookparms.getCookTime(), 0);
1489  return result;
1490  }
1491  bool getUseAxBPolys() const { return myUseAxBPolys; }
1492  void setUseAxBPolys(bool val) { myUseAxBPolys = val; }
1493  bool opUseAxBPolys(const SOP_NodeVerb::CookParms &cookparms) const
1494  {
1495  SOP_Node *thissop = cookparms.getNode();
1496  if (!thissop) return getUseAxBPolys();
1497  bool result;
1498  OP_Utils::evalOpParm(result, thissop, "useaxbpolys", cookparms.getCookTime(), 0);
1499  return result;
1500  }
1501  const UT_StringHolder & getAxBPolys() const { return myAxBPolys; }
1502  void setAxBPolys(const UT_StringHolder & val) { myAxBPolys = val; }
1504  {
1505  SOP_Node *thissop = cookparms.getNode();
1506  if (!thissop) return getAxBPolys();
1507  UT_StringHolder result;
1508  OP_Utils::evalOpParm(result, thissop, "axbpolys", cookparms.getCookTime(), 0);
1509  return result;
1510  }
1511  bool getUseAxAList() const { return myUseAxAList; }
1512  void setUseAxAList(bool val) { myUseAxAList = val; }
1513  bool opUseAxAList(const SOP_NodeVerb::CookParms &cookparms) const
1514  {
1515  SOP_Node *thissop = cookparms.getNode();
1516  if (!thissop) return getUseAxAList();
1517  bool result;
1518  OP_Utils::evalOpParm(result, thissop, "useaxalist", cookparms.getCookTime(), 0);
1519  return result;
1520  }
1521  const UT_StringHolder & getAxAList() const { return myAxAList; }
1522  void setAxAList(const UT_StringHolder & val) { myAxAList = val; }
1524  {
1525  SOP_Node *thissop = cookparms.getNode();
1526  if (!thissop) return getAxAList();
1527  UT_StringHolder result;
1528  OP_Utils::evalOpParm(result, thissop, "axalist", cookparms.getCookTime(), 0);
1529  return result;
1530  }
1531  bool getUseAxBList() const { return myUseAxBList; }
1532  void setUseAxBList(bool val) { myUseAxBList = val; }
1533  bool opUseAxBList(const SOP_NodeVerb::CookParms &cookparms) const
1534  {
1535  SOP_Node *thissop = cookparms.getNode();
1536  if (!thissop) return getUseAxBList();
1537  bool result;
1538  OP_Utils::evalOpParm(result, thissop, "useaxblist", cookparms.getCookTime(), 0);
1539  return result;
1540  }
1541  const UT_StringHolder & getAxBList() const { return myAxBList; }
1542  void setAxBList(const UT_StringHolder & val) { myAxBList = val; }
1544  {
1545  SOP_Node *thissop = cookparms.getNode();
1546  if (!thissop) return getAxBList();
1547  UT_StringHolder result;
1548  OP_Utils::evalOpParm(result, thissop, "axblist", cookparms.getCookTime(), 0);
1549  return result;
1550  }
1551  bool getCollapseTinyEdges() const { return myCollapseTinyEdges; }
1552  void setCollapseTinyEdges(bool val) { myCollapseTinyEdges = val; }
1553  bool opCollapseTinyEdges(const SOP_NodeVerb::CookParms &cookparms) const
1554  {
1555  SOP_Node *thissop = cookparms.getNode();
1556  if (!thissop) return getCollapseTinyEdges();
1557  bool result;
1558  OP_Utils::evalOpParm(result, thissop, "collapsetinyedges", cookparms.getCookTime(), 0);
1559  return result;
1560  }
1561  fpreal64 getLengthThreshold() const { return myLengthThreshold; }
1562  void setLengthThreshold(fpreal64 val) { myLengthThreshold = val; }
1564  {
1565  SOP_Node *thissop = cookparms.getNode();
1566  if (!thissop) return getLengthThreshold();
1567  fpreal64 result;
1568  OP_Utils::evalOpParm(result, thissop, "lengththreshold", cookparms.getCookTime(), 0);
1569  return result;
1570  }
1571  bool getUseAPolys() const { return myUseAPolys; }
1572  void setUseAPolys(bool val) { myUseAPolys = val; }
1573  bool opUseAPolys(const SOP_NodeVerb::CookParms &cookparms) const
1574  {
1575  SOP_Node *thissop = cookparms.getNode();
1576  if (!thissop) return getUseAPolys();
1577  bool result;
1578  OP_Utils::evalOpParm(result, thissop, "useapolys", cookparms.getCookTime(), 0);
1579  return result;
1580  }
1581  const UT_StringHolder & getAPolys() const { return myAPolys; }
1582  void setAPolys(const UT_StringHolder & val) { myAPolys = val; }
1584  {
1585  SOP_Node *thissop = cookparms.getNode();
1586  if (!thissop) return getAPolys();
1587  UT_StringHolder result;
1588  OP_Utils::evalOpParm(result, thissop, "apolys", cookparms.getCookTime(), 0);
1589  return result;
1590  }
1591  bool getUseAInsideB() const { return myUseAInsideB; }
1592  void setUseAInsideB(bool val) { myUseAInsideB = val; }
1593  bool opUseAInsideB(const SOP_NodeVerb::CookParms &cookparms) const
1594  {
1595  SOP_Node *thissop = cookparms.getNode();
1596  if (!thissop) return getUseAInsideB();
1597  bool result;
1598  OP_Utils::evalOpParm(result, thissop, "useainsideb", cookparms.getCookTime(), 0);
1599  return result;
1600  }
1601  const UT_StringHolder & getAInsideB() const { return myAInsideB; }
1602  void setAInsideB(const UT_StringHolder & val) { myAInsideB = val; }
1604  {
1605  SOP_Node *thissop = cookparms.getNode();
1606  if (!thissop) return getAInsideB();
1607  UT_StringHolder result;
1608  OP_Utils::evalOpParm(result, thissop, "ainsideb", cookparms.getCookTime(), 0);
1609  return result;
1610  }
1611  bool getUseAOutsideB() const { return myUseAOutsideB; }
1612  void setUseAOutsideB(bool val) { myUseAOutsideB = val; }
1613  bool opUseAOutsideB(const SOP_NodeVerb::CookParms &cookparms) const
1614  {
1615  SOP_Node *thissop = cookparms.getNode();
1616  if (!thissop) return getUseAOutsideB();
1617  bool result;
1618  OP_Utils::evalOpParm(result, thissop, "useaoutsideb", cookparms.getCookTime(), 0);
1619  return result;
1620  }
1621  const UT_StringHolder & getAOutsideB() const { return myAOutsideB; }
1622  void setAOutsideB(const UT_StringHolder & val) { myAOutsideB = val; }
1624  {
1625  SOP_Node *thissop = cookparms.getNode();
1626  if (!thissop) return getAOutsideB();
1627  UT_StringHolder result;
1628  OP_Utils::evalOpParm(result, thissop, "aoutsideb", cookparms.getCookTime(), 0);
1629  return result;
1630  }
1631  bool getUseBPolys() const { return myUseBPolys; }
1632  void setUseBPolys(bool val) { myUseBPolys = val; }
1633  bool opUseBPolys(const SOP_NodeVerb::CookParms &cookparms) const
1634  {
1635  SOP_Node *thissop = cookparms.getNode();
1636  if (!thissop) return getUseBPolys();
1637  bool result;
1638  OP_Utils::evalOpParm(result, thissop, "usebpolys", cookparms.getCookTime(), 0);
1639  return result;
1640  }
1641  const UT_StringHolder & getBPolys() const { return myBPolys; }
1642  void setBPolys(const UT_StringHolder & val) { myBPolys = val; }
1644  {
1645  SOP_Node *thissop = cookparms.getNode();
1646  if (!thissop) return getBPolys();
1647  UT_StringHolder result;
1648  OP_Utils::evalOpParm(result, thissop, "bpolys", cookparms.getCookTime(), 0);
1649  return result;
1650  }
1651  bool getUseBInsideA() const { return myUseBInsideA; }
1652  void setUseBInsideA(bool val) { myUseBInsideA = val; }
1653  bool opUseBInsideA(const SOP_NodeVerb::CookParms &cookparms) const
1654  {
1655  SOP_Node *thissop = cookparms.getNode();
1656  if (!thissop) return getUseBInsideA();
1657  bool result;
1658  OP_Utils::evalOpParm(result, thissop, "usebinsidea", cookparms.getCookTime(), 0);
1659  return result;
1660  }
1661  const UT_StringHolder & getBInsideA() const { return myBInsideA; }
1662  void setBInsideA(const UT_StringHolder & val) { myBInsideA = val; }
1664  {
1665  SOP_Node *thissop = cookparms.getNode();
1666  if (!thissop) return getBInsideA();
1667  UT_StringHolder result;
1668  OP_Utils::evalOpParm(result, thissop, "binsidea", cookparms.getCookTime(), 0);
1669  return result;
1670  }
1671  bool getUseBOutsideA() const { return myUseBOutsideA; }
1672  void setUseBOutsideA(bool val) { myUseBOutsideA = val; }
1673  bool opUseBOutsideA(const SOP_NodeVerb::CookParms &cookparms) const
1674  {
1675  SOP_Node *thissop = cookparms.getNode();
1676  if (!thissop) return getUseBOutsideA();
1677  bool result;
1678  OP_Utils::evalOpParm(result, thissop, "useboutsidea", cookparms.getCookTime(), 0);
1679  return result;
1680  }
1681  const UT_StringHolder & getBOutsideA() const { return myBOutsideA; }
1682  void setBOutsideA(const UT_StringHolder & val) { myBOutsideA = val; }
1684  {
1685  SOP_Node *thissop = cookparms.getNode();
1686  if (!thissop) return getBOutsideA();
1687  UT_StringHolder result;
1688  OP_Utils::evalOpParm(result, thissop, "boutsidea", cookparms.getCookTime(), 0);
1689  return result;
1690  }
1691  bool getUseABOverlap() const { return myUseABOverlap; }
1692  void setUseABOverlap(bool val) { myUseABOverlap = val; }
1693  bool opUseABOverlap(const SOP_NodeVerb::CookParms &cookparms) const
1694  {
1695  SOP_Node *thissop = cookparms.getNode();
1696  if (!thissop) return getUseABOverlap();
1697  bool result;
1698  OP_Utils::evalOpParm(result, thissop, "useaboverlap", cookparms.getCookTime(), 0);
1699  return result;
1700  }
1701  const UT_StringHolder & getABOverlap() const { return myABOverlap; }
1702  void setABOverlap(const UT_StringHolder & val) { myABOverlap = val; }
1704  {
1705  SOP_Node *thissop = cookparms.getNode();
1706  if (!thissop) return getABOverlap();
1707  UT_StringHolder result;
1708  OP_Utils::evalOpParm(result, thissop, "aboverlap", cookparms.getCookTime(), 0);
1709  return result;
1710  }
1711  bool getUseAPieces() const { return myUseAPieces; }
1712  void setUseAPieces(bool val) { myUseAPieces = val; }
1713  bool opUseAPieces(const SOP_NodeVerb::CookParms &cookparms) const
1714  {
1715  SOP_Node *thissop = cookparms.getNode();
1716  if (!thissop) return getUseAPieces();
1717  bool result;
1718  OP_Utils::evalOpParm(result, thissop, "useaonlypieces", cookparms.getCookTime(), 0);
1719  return result;
1720  }
1721  const UT_StringHolder & getAPieces() const { return myAPieces; }
1722  void setAPieces(const UT_StringHolder & val) { myAPieces = val; }
1724  {
1725  SOP_Node *thissop = cookparms.getNode();
1726  if (!thissop) return getAPieces();
1727  UT_StringHolder result;
1728  OP_Utils::evalOpParm(result, thissop, "aonlypieces", cookparms.getCookTime(), 0);
1729  return result;
1730  }
1731  bool getUseBPieces() const { return myUseBPieces; }
1732  void setUseBPieces(bool val) { myUseBPieces = val; }
1733  bool opUseBPieces(const SOP_NodeVerb::CookParms &cookparms) const
1734  {
1735  SOP_Node *thissop = cookparms.getNode();
1736  if (!thissop) return getUseBPieces();
1737  bool result;
1738  OP_Utils::evalOpParm(result, thissop, "usebonlypieces", cookparms.getCookTime(), 0);
1739  return result;
1740  }
1741  const UT_StringHolder & getBPieces() const { return myBPieces; }
1742  void setBPieces(const UT_StringHolder & val) { myBPieces = val; }
1744  {
1745  SOP_Node *thissop = cookparms.getNode();
1746  if (!thissop) return getBPieces();
1747  UT_StringHolder result;
1748  OP_Utils::evalOpParm(result, thissop, "bonlypieces", cookparms.getCookTime(), 0);
1749  return result;
1750  }
1751  bool getUseABPieces() const { return myUseABPieces; }
1752  void setUseABPieces(bool val) { myUseABPieces = val; }
1753  bool opUseABPieces(const SOP_NodeVerb::CookParms &cookparms) const
1754  {
1755  SOP_Node *thissop = cookparms.getNode();
1756  if (!thissop) return getUseABPieces();
1757  bool result;
1758  OP_Utils::evalOpParm(result, thissop, "useabpieces", cookparms.getCookTime(), 0);
1759  return result;
1760  }
1761  const UT_StringHolder & getABPieces() const { return myABPieces; }
1762  void setABPieces(const UT_StringHolder & val) { myABPieces = val; }
1764  {
1765  SOP_Node *thissop = cookparms.getNode();
1766  if (!thissop) return getABPieces();
1767  UT_StringHolder result;
1768  OP_Utils::evalOpParm(result, thissop, "abpieces", cookparms.getCookTime(), 0);
1769  return result;
1770  }
1771  bool getUseAASeamEdges() const { return myUseAASeamEdges; }
1772  void setUseAASeamEdges(bool val) { myUseAASeamEdges = val; }
1773  bool opUseAASeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
1774  {
1775  SOP_Node *thissop = cookparms.getNode();
1776  if (!thissop) return getUseAASeamEdges();
1777  bool result;
1778  OP_Utils::evalOpParm(result, thissop, "useaaseamedges", cookparms.getCookTime(), 0);
1779  return result;
1780  }
1781  const UT_StringHolder & getAASeamEdges() const { return myAASeamEdges; }
1782  void setAASeamEdges(const UT_StringHolder & val) { myAASeamEdges = val; }
1784  {
1785  SOP_Node *thissop = cookparms.getNode();
1786  if (!thissop) return getAASeamEdges();
1787  UT_StringHolder result;
1788  OP_Utils::evalOpParm(result, thissop, "aaseamedges", cookparms.getCookTime(), 0);
1789  return result;
1790  }
1791  bool getUseBBSeamEdges() const { return myUseBBSeamEdges; }
1792  void setUseBBSeamEdges(bool val) { myUseBBSeamEdges = val; }
1793  bool opUseBBSeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
1794  {
1795  SOP_Node *thissop = cookparms.getNode();
1796  if (!thissop) return getUseBBSeamEdges();
1797  bool result;
1798  OP_Utils::evalOpParm(result, thissop, "usebbseamedges", cookparms.getCookTime(), 0);
1799  return result;
1800  }
1801  const UT_StringHolder & getBBSeamEdges() const { return myBBSeamEdges; }
1802  void setBBSeamEdges(const UT_StringHolder & val) { myBBSeamEdges = val; }
1804  {
1805  SOP_Node *thissop = cookparms.getNode();
1806  if (!thissop) return getBBSeamEdges();
1807  UT_StringHolder result;
1808  OP_Utils::evalOpParm(result, thissop, "bbseamedges", cookparms.getCookTime(), 0);
1809  return result;
1810  }
1811  bool getUseABSeamEdges() const { return myUseABSeamEdges; }
1812  void setUseABSeamEdges(bool val) { myUseABSeamEdges = val; }
1813  bool opUseABSeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
1814  {
1815  SOP_Node *thissop = cookparms.getNode();
1816  if (!thissop) return getUseABSeamEdges();
1817  bool result;
1818  OP_Utils::evalOpParm(result, thissop, "useabseamedges", cookparms.getCookTime(), 0);
1819  return result;
1820  }
1821  const UT_StringHolder & getABSeamEdges() const { return myABSeamEdges; }
1822  void setABSeamEdges(const UT_StringHolder & val) { myABSeamEdges = val; }
1824  {
1825  SOP_Node *thissop = cookparms.getNode();
1826  if (!thissop) return getABSeamEdges();
1827  UT_StringHolder result;
1828  OP_Utils::evalOpParm(result, thissop, "abseamedges", cookparms.getCookTime(), 0);
1829  return result;
1830  }
1831  UT_Vector2I getDepthInA() const { return myDepthInA; }
1832  void setDepthInA(UT_Vector2I val) { myDepthInA = val; }
1834  {
1835  SOP_Node *thissop = cookparms.getNode();
1836  if (!thissop) return getDepthInA();
1837  UT_Vector2I result;
1838  OP_Utils::evalOpParm(result, thissop, "adepth", cookparms.getCookTime(), 0);
1839  return result;
1840  }
1841  UT_Vector2I getDepthInB() const { return myDepthInB; }
1842  void setDepthInB(UT_Vector2I val) { myDepthInB = val; }
1844  {
1845  SOP_Node *thissop = cookparms.getNode();
1846  if (!thissop) return getDepthInB();
1847  UT_Vector2I result;
1848  OP_Utils::evalOpParm(result, thissop, "bdepth", cookparms.getCookTime(), 0);
1849  return result;
1850  }
1851 
1852 private:
1853  UT_StringHolder myGroupA;
1854  int64 myASurface;
1855  bool myResolveA;
1856  UT_StringHolder myGroupB;
1857  int64 myBSurface;
1858  bool myResolveB;
1859  int64 myBooleanOp;
1860  int64 mySubtractChoices;
1861  int64 myShatterChoices;
1862  bool myOpenCurvesOnly;
1863  bool myGenerateAASeams;
1864  bool myGenerateBBSeams;
1865  bool myGenerateABSeams;
1866  int64 myWindingOp;
1867  bool myMergeNbrs;
1868  int64 myDetriangulate;
1869  bool myRemoveInlinePoints;
1870  bool myUniqueSeams;
1871  bool myUseAxAPolys;
1872  UT_StringHolder myAxAPolys;
1873  bool myUseAxBPolys;
1874  UT_StringHolder myAxBPolys;
1875  bool myUseAxAList;
1876  UT_StringHolder myAxAList;
1877  bool myUseAxBList;
1878  UT_StringHolder myAxBList;
1879  bool myCollapseTinyEdges;
1880  fpreal64 myLengthThreshold;
1881  bool myUseAPolys;
1882  UT_StringHolder myAPolys;
1883  bool myUseAInsideB;
1884  UT_StringHolder myAInsideB;
1885  bool myUseAOutsideB;
1886  UT_StringHolder myAOutsideB;
1887  bool myUseBPolys;
1888  UT_StringHolder myBPolys;
1889  bool myUseBInsideA;
1890  UT_StringHolder myBInsideA;
1891  bool myUseBOutsideA;
1892  UT_StringHolder myBOutsideA;
1893  bool myUseABOverlap;
1894  UT_StringHolder myABOverlap;
1895  bool myUseAPieces;
1896  UT_StringHolder myAPieces;
1897  bool myUseBPieces;
1898  UT_StringHolder myBPieces;
1899  bool myUseABPieces;
1900  UT_StringHolder myABPieces;
1901  bool myUseAASeamEdges;
1902  UT_StringHolder myAASeamEdges;
1903  bool myUseBBSeamEdges;
1904  UT_StringHolder myBBSeamEdges;
1905  bool myUseABSeamEdges;
1906  UT_StringHolder myABSeamEdges;
1907  UT_Vector2I myDepthInA;
1908  UT_Vector2I myDepthInB;
1909 
1910 };
void setParmValue(exint idx, const UT_Matrix4D &value)
bool opUseABSeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector2D v)
static void saveData(std::ostream &os, bool v)
UT_Vector2T< int64 > UT_Vector2I
static void loadData(UT_IStream &is, UT_Vector3D &v)
bool opRemoveInlinePoints(const SOP_NodeVerb::CookParms &cookparms) const
bool getRemoveInlinePoints() const
BooleanOp getBooleanOp() const
ShatterChoices getShatterChoices() const
bool opGenerateBBSeams(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector4D v)
bool opUseAASeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
bool opGenerateAASeams(const SOP_NodeVerb::CookParms &cookparms) const
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:494
void setDetriangulate(Detriangulate val)
static void loadData(UT_IStream &is, int64 &v)
T & z(void)
Definition: UT_Vector4.h:379
void setWindingOp(WindingOp val)
void setUseABOverlap(bool val)
void setUniqueSeams(bool val)
void setGroupB(const UT_StringHolder &val)
bool getUseABSeamEdges() const
UT_StringHolder opAPolys(const SOP_NodeVerb::CookParms &cookparms) const
BSurface opBSurface(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const PRM_DataItemHandle &value)
void save(std::ostream &os) const
UT_StringHolder opAxBPolys(const SOP_NodeVerb::CookParms &cookparms) const
void setAPieces(const UT_StringHolder &val)
bool opUseAxBPolys(const SOP_NodeVerb::CookParms &cookparms) const
void doSetParmValue(exint idx, const T &value)
bool opUseAPieces(const SOP_NodeVerb::CookParms &cookparms) const
bool operator!=(const SOP_BooleanParms &src) const
static void saveData(std::ostream &os, fpreal64 v)
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
virtual void loadFromOpSubclass(const LoadParms &loadparms)
static void loadData(UT_IStream &is, fpreal64 &v)
bool getUseAxBPolys() const
fpreal getTime() const
Definition: OP_Context.h:60
const GLdouble * v
Definition: glcorearb.h:836
UT_StringHolder opAxAPolys(const SOP_NodeVerb::CookParms &cookparms) const
BSurface getBSurface() const
UT_StringHolder opGroupA(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opABOverlap(const SOP_NodeVerb::CookParms &cookparms) const
void setSubtractChoices(SubtractChoices val)
bool getUseAxBList() const
void setUseABPieces(bool val)
bool opGenerateABSeams(const SOP_NodeVerb::CookParms &cookparms) const
bool getOpenCurvesOnly() const
void setUseABSeamEdges(bool val)
bool opUseBOutsideA(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseAPieces() const
static void saveData(std::ostream &os, UT_Vector3D v)
void setUseAPolys(bool val)
void getParmValue(exint idx, UT_Vector3D &value) const
SYS_FORCE_INLINE const char * buffer() const
T & x(void)
Definition: UT_Vector2.h:285
void setAPolys(const UT_StringHolder &val)
void setAInsideB(const UT_StringHolder &val)
const UT_StringHolder & getGroupA() const
virtual ParmType getParmType(exint fieldnum) const
An output stream object that owns its own string buffer storage.
static void saveData(std::ostream &os, UT_Matrix4D v)
void setParmValue(exint idx, const UT_StringHolder &value)
ASurface getASurface() const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
static void loadData(UT_IStream &is, UT_Matrix3D &v)
bool getCollapseTinyEdges() const
void setAxAList(const UT_StringHolder &val)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:498
void setParmValue(exint idx, const UT_Matrix2D &value)
bool getUniqueSeams() const
UT_Vector2I opDepthInA(const SOP_NodeVerb::CookParms &cookparms) const
void setUseAASeamEdges(bool val)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void setUseBPolys(bool val)
static void loadData(UT_IStream &is, UT_Vector3I &v)
const UT_StringHolder & getBPieces() const
void setCollapseTinyEdges(bool val)
fpreal64 opLengthThreshold(const SOP_NodeVerb::CookParms &cookparms) const
void setMergeNbrs(bool val)
bool getUseAInsideB() const
UT_StringHolder opAInsideB(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Vector2D &value)
void setBOutsideA(const UT_StringHolder &val)
bool opResolveA(const SOP_NodeVerb::CookParms &cookparms) const
WindingOp opWindingOp(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Matrix2D &value) const
bool opOpenCurvesOnly(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const fpreal &value)
bool opUseAPolys(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, PRM_DataItemHandle &value) const
void setUseAInsideB(bool val)
const UT_StringHolder & getBInsideA() const
bool getUseBOutsideA() const
bool opUniqueSeams(const SOP_NodeVerb::CookParms &cookparms) const
bool load(UT_IStream &is)
bool getUseBPolys() const
bool opUseAOutsideB(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:502
void setBooleanOp(BooleanOp val)
bool getUseAASeamEdges() const
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
long long int64
Definition: SYS_Types.h:107
bool getUseBPieces() const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void setParmValue(exint idx, const UT_Vector3D &value)
UT_StringHolder opAxAList(const SOP_NodeVerb::CookParms &cookparms) const
bool getGenerateABSeams() const
UT_StringHolder opBBSeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, int64 v)
const UT_StringHolder & getBPolys() const
void setABOverlap(const UT_StringHolder &val)
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
void setAxBPolys(const UT_StringHolder &val)
void setParmValue(exint idx, const exint &value)
UT_StringHolder opAOutsideB(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseBPolys(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2I getDepthInB() const
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
UT_Vector2I opDepthInB(const SOP_NodeVerb::CookParms &cookparms) const
int64 exint
Definition: SYS_Types.h:116
bool opUseAInsideB(const SOP_NodeVerb::CookParms &cookparms) const
void setResolveA(bool val)
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
static void loadData(UT_IStream &is, UT_Vector2D &v)
double fpreal64
Definition: SYS_Types.h:192
static int version()
bool getUseAxAPolys() const
fpreal64 getLengthThreshold() const
void setUseAxAPolys(bool val)
bool opUseAxAPolys(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseABPieces(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Matrix3D &value) const
const UT_StringHolder & getAPolys() const
static void loadData(UT_IStream &is, UT_StringHolder &v)
bool opMergeNbrs(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getABOverlap() const
const UT_StringHolder & getBBSeamEdges() const
void setResolveB(bool val)
void setAASeamEdges(const UT_StringHolder &val)
bool opResolveB(const SOP_NodeVerb::CookParms &cookparms) const
void setAxAPolys(const UT_StringHolder &val)
void setDepthInB(UT_Vector2I val)
void setGroupA(const UT_StringHolder &val)
virtual const char * getParmName(exint fieldnum) const
SubtractChoices opSubtractChoices(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseBInsideA(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getAASeamEdges() const
static void saveData(std::ostream &os, UT_Matrix3D v)
const UT_StringHolder & getGroupB() const
void setASurface(ASurface val)
void setUseAOutsideB(bool val)
void getParmValue(exint idx, UT_StringHolder &value) const
bool getGenerateBBSeams() const
bool opUseABOverlap(const SOP_NodeVerb::CookParms &cookparms) const
GLboolean * data
Definition: glcorearb.h:130
UT_StringHolder opABPieces(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getAxBList() const
int int32
Definition: SYS_Types.h:35
void setGenerateBBSeams(bool val)
bool opUseAxAList(const SOP_NodeVerb::CookParms &cookparms) const
T & y(void)
Definition: UT_Vector4.h:377
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
static void loadData(UT_IStream &is, UT_Vector2I &v)
bool getResolveB() const
bool opUseAxBList(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opABSeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseAPolys() const
ASurface opASurface(const SOP_NodeVerb::CookParms &cookparms) const
void setUseAxAList(bool val)
void setRemoveInlinePoints(bool val)
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
void getParmValue(exint idx, UT_Vector4D &value) const
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
const UT_StringHolder & getABPieces() const
virtual exint getNumParms() const
bool opUseBPieces(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getAxBPolys() const
UT_StringHolder opAxBList(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getAInsideB() const
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:500
void setAxBList(const UT_StringHolder &val)
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:270
void setBSurface(BSurface val)
void setDepthInA(UT_Vector2I val)
Detriangulate getDetriangulate() const
void setBPolys(const UT_StringHolder &val)
UT_StringHolder opBPolys(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseBInsideA() const
void setBInsideA(const UT_StringHolder &val)
bool getUseABPieces() const
bool getResolveA() const
void setGenerateABSeams(bool val)
ShatterChoices opShatterChoices(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getAxAList() const
void setUseBOutsideA(bool val)
void getParmValue(exint idx, UT_Vector2D &value) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
bool opCollapseTinyEdges(const SOP_NodeVerb::CookParms &cookparms) const
BooleanOp opBooleanOp(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const SOP_BooleanParms &src) const
Detriangulate opDetriangulate(const SOP_NodeVerb::CookParms &cookparms) const
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
bool getMergeNbrs() const
void setUseAPieces(bool val)
void setABPieces(const UT_StringHolder &val)
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
void setUseBPieces(bool val)
void setParmValue(exint idx, const UT_Matrix3D &value)
UT_StringHolder opAPieces(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_StringHolder s)
GLuint GLfloat * val
Definition: glcorearb.h:1607
void doGetParmValue(exint idx, T &value) const
WindingOp getWindingOp() const
#define SOP_API
Definition: SOP_API.h:10
virtual ~SOP_BooleanParms()
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void setLengthThreshold(fpreal64 val)
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:501
const UT_StringHolder & getBOutsideA() const
void setUseAxBList(bool val)
void setUseBInsideA(bool val)
T & x(void)
Definition: UT_Vector4.h:375
static void loadData(UT_IStream &is, UT_Vector4I &v)
bool opUseBBSeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2I getDepthInA() const
T & y(void)
Definition: UT_Vector2.h:287
const UT_StringHolder & getAOutsideB() const
void getParmValue(exint idx, exint &value) const
bool getUseAxAList() const
void getParmValue(exint idx, UT_Matrix4D &value) const
void setParmValue(exint idx, const UT_Vector4D &value)
GLboolean r
Definition: glcorearb.h:1221
UT_StringHolder opAASeamEdges(const SOP_NodeVerb::CookParms &cookparms) const
void setUseAxBPolys(bool val)
static void loadData(UT_IStream &is, UT_Vector4D &v)
const UT_StringHolder & getAPieces() const
void setGenerateAASeams(bool val)
void setBBSeamEdges(const UT_StringHolder &val)
void setUseBBSeamEdges(bool val)
T & w(void)
Definition: UT_Vector4.h:381
void setBPieces(const UT_StringHolder &val)
void setShatterChoices(ShatterChoices val)
void getParmValue(exint idx, fpreal &value) const
void setABSeamEdges(const UT_StringHolder &val)
const UT_StringHolder & getABSeamEdges() const
void setOpenCurvesOnly(bool val)
const UT_StringHolder & getAxAPolys() const
bool getUseAOutsideB() const
UT_StringHolder opBPieces(const SOP_NodeVerb::CookParms &cookparms) const
void setAOutsideB(const UT_StringHolder &val)
static void loadData(UT_IStream &is, bool &v)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:88
UT_StringHolder opBInsideA(const SOP_NodeVerb::CookParms &cookparms) const
SubtractChoices getSubtractChoices() const
static void saveData(std::ostream &os, UT_Matrix2D v)
SYS_FORCE_INLINE bool isstring() const
UT_StringHolder opGroupB(const SOP_NodeVerb::CookParms &cookparms) const
bool getGenerateAASeams() const
UT_StringHolder opBOutsideA(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseBBSeamEdges() const
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
bool getUseABOverlap() const
static void loadData(UT_IStream &is, UT_Matrix4D &v)
GLenum src
Definition: glcorearb.h:1792
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
virtual void copyFrom(const SOP_NodeParms *src)