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