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