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