HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_UVLayout-3.0.proto.h
Go to the documentation of this file.
1 /* Automagically Generated by generate_proto.py
2  * Do not Edit
3  */
4 #pragma once
5 
6 #include <SOP/SOP_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 using namespace UT::Literal;
23 
24 class DEP_MicroNode;
25 namespace SOP_UVLayout_3_0Enums
26 {
27  enum class UVProjPlane
28  {
29  XY = 0,
30  YZ,
31  ZX
32  };
33  enum class AxisAlignment
34  {
35  NONE = 0,
36  INTRINSIC,
37  EXTRINSIC
38  };
39  enum class Scaling
40  {
41  AUTO = 0,
42  CUSTOM
43  };
44  enum class RotationStep
45  {
46  NONE = 0,
47  PI,
48  PI2,
49  PI4,
50  PI8,
51  PI16,
52  PI32,
53  CUSTOM
54  };
55  enum class Resolution
56  {
57  RES1 = 0,
58  RES2,
59  RES3,
60  RES4,
61  RES5,
62  CUSTOM
63  };
64  enum class TargetType
65  {
66  BOXES = 0,
67  UDIM,
68  GEO
69  };
70  enum class TargetProjPlane
71  {
72  XY = 0,
73  YZ,
74  ZX
75  };
76 }
77 
78 
80 {
81 public:
82  static int version() { return 1; }
83  struct Rects
84  {
85  bool rect_use;
88 
89 
91  {
92  rect_use = true;
93  rect_center = UT_Vector2D(0.5,0.5);
94  rect_size = UT_Vector2D(1,1);
95 
96  }
97 
98  bool operator==(const Rects &src) const
99  {
100  if (rect_use != src.rect_use) return false;
101  if (rect_center != src.rect_center) return false;
102  if (rect_size != src.rect_size) return false;
103 
104  return true;
105  }
106  bool operator!=(const Rects &src) const
107  {
108  return !operator==(src);
109  }
110 
111  };
112 
114  {
116 
117  buf.strcat("[ ");
118  for (int i = 0; i < list.entries(); i++)
119  {
120  if (i)
121  buf.strcat(", ");
122  buf.strcat("( ");
123  buf.append("");
124  buf.appendSprintf("%s", (list(i).rect_use) ? "true" : "false");
125  buf.append(", ");
126  buf.appendSprintf("(%f, %f)", list(i).rect_center.x(), list(i).rect_center.y());
127  buf.append(", ");
128  buf.appendSprintf("(%f, %f)", list(i).rect_size.x(), list(i).rect_size.y());
129 
130  buf.strcat(" )");
131  }
132  buf.strcat(" ]");
133 
135  return result;
136  }
137 
139  {
140  myUVAttr = "uv"_sh;
141  myUVProjPlane = 0;
142  myGroup = ""_sh;
143  mySeparatorEdges = ""_sh;
144  myUseIslandAttr = false;
145  myIslandAttr = "island"_sh;
146  myUseTargetAttr = false;
147  myTargetAttr = "udim"_sh;
148  myTargetOverrides = ""_sh;
149  myUseIslandScaleAttr = false;
150  myIslandScaleAttr = "iscale"_sh;
151  myScaleOverrides = ""_sh;
152  myUseIslandOffsetAttr = false;
153  myIslandOffsetAttr = "ioffset"_sh;
154  myOffsetOverrides = ""_sh;
155  myCorrectAreas = false;
156  myAxisAlignment = 1;
157  myScaling = 0;
158  myScale = 1;
159  myRotationStep = 0;
160  myCircleDivs = 1;
161  myPackBetween = false;
162  myPackInCavities = true;
163  myPadding = 1;
164  myPadBoundaries = false;
165  myExpandPadding = false;
166  myIterations = 1;
167  myResolution = 2;
168  myCustomResolution = 1024;
169  myConnectivityTolerance = 1e-05;
170  myScaleTolerance = 0.005;
171  myRandSeed = 5489;
172  myTargetType = 0;
173  myUseDefaultTarget = false;
174  myDefaultTarget = 0;
175  myUseDefaultUdimTarget = false;
176  myDefaultUdimTarget = 1001;
177  myRects.setSize(1);
178  myTileSize = UT_Vector2D(1,1);
179  myNumColumns = 10;
180  myStartingUdim = 1001;
181  myTargetUVAttr = "uv"_sh;
182  myTargetProjPlane = 0;
183  myTargetGroup = ""_sh;
184  myTargetSeparatorEdges = ""_sh;
185  myUseTargetIslandAttr = false;
186  myTargetIslandAttr = "targetisland"_sh;
187  myStackIslands = false;
188  myStackMirrored = false;
189  myStackOnNonGroup = false;
190  myStackingLengthTolerance = 0.02;
191  myGenerateNonpackedPolys = false;
192  myNonpackedPolys = "nonpacked"_sh;
193  myGenerateIslandAttr = false;
194  myOutputIslandAttr = "island"_sh;
195  myGenerateTargetAttr = false;
196  myOutputTargetAttr = "target"_sh;
197 
198  }
199 
200  explicit SOP_UVLayout_3_0Parms(const SOP_UVLayout_3_0Parms &) = default;
201 
203 
205  {
206  if (myUVAttr != src.myUVAttr) return false;
207  if (myUVProjPlane != src.myUVProjPlane) return false;
208  if (myGroup != src.myGroup) return false;
209  if (mySeparatorEdges != src.mySeparatorEdges) return false;
210  if (myUseIslandAttr != src.myUseIslandAttr) return false;
211  if (myIslandAttr != src.myIslandAttr) return false;
212  if (myUseTargetAttr != src.myUseTargetAttr) return false;
213  if (myTargetAttr != src.myTargetAttr) return false;
214  if (myTargetOverrides != src.myTargetOverrides) return false;
215  if (myUseIslandScaleAttr != src.myUseIslandScaleAttr) return false;
216  if (myIslandScaleAttr != src.myIslandScaleAttr) return false;
217  if (myScaleOverrides != src.myScaleOverrides) return false;
218  if (myUseIslandOffsetAttr != src.myUseIslandOffsetAttr) return false;
219  if (myIslandOffsetAttr != src.myIslandOffsetAttr) return false;
220  if (myOffsetOverrides != src.myOffsetOverrides) return false;
221  if (myCorrectAreas != src.myCorrectAreas) return false;
222  if (myAxisAlignment != src.myAxisAlignment) return false;
223  if (myScaling != src.myScaling) return false;
224  if (myScale != src.myScale) return false;
225  if (myRotationStep != src.myRotationStep) return false;
226  if (myCircleDivs != src.myCircleDivs) return false;
227  if (myPackBetween != src.myPackBetween) return false;
228  if (myPackInCavities != src.myPackInCavities) return false;
229  if (myPadding != src.myPadding) return false;
230  if (myPadBoundaries != src.myPadBoundaries) return false;
231  if (myExpandPadding != src.myExpandPadding) return false;
232  if (myIterations != src.myIterations) return false;
233  if (myResolution != src.myResolution) return false;
234  if (myCustomResolution != src.myCustomResolution) return false;
235  if (myConnectivityTolerance != src.myConnectivityTolerance) return false;
236  if (myScaleTolerance != src.myScaleTolerance) return false;
237  if (myRandSeed != src.myRandSeed) return false;
238  if (myTargetType != src.myTargetType) return false;
239  if (myUseDefaultTarget != src.myUseDefaultTarget) return false;
240  if (myDefaultTarget != src.myDefaultTarget) return false;
241  if (myUseDefaultUdimTarget != src.myUseDefaultUdimTarget) return false;
242  if (myDefaultUdimTarget != src.myDefaultUdimTarget) return false;
243  if (myRects != src.myRects) return false;
244  if (myTileSize != src.myTileSize) return false;
245  if (myNumColumns != src.myNumColumns) return false;
246  if (myStartingUdim != src.myStartingUdim) return false;
247  if (myTargetUVAttr != src.myTargetUVAttr) return false;
248  if (myTargetProjPlane != src.myTargetProjPlane) return false;
249  if (myTargetGroup != src.myTargetGroup) return false;
250  if (myTargetSeparatorEdges != src.myTargetSeparatorEdges) return false;
251  if (myUseTargetIslandAttr != src.myUseTargetIslandAttr) return false;
252  if (myTargetIslandAttr != src.myTargetIslandAttr) return false;
253  if (myStackIslands != src.myStackIslands) return false;
254  if (myStackMirrored != src.myStackMirrored) return false;
255  if (myStackOnNonGroup != src.myStackOnNonGroup) return false;
256  if (myStackingLengthTolerance != src.myStackingLengthTolerance) return false;
257  if (myGenerateNonpackedPolys != src.myGenerateNonpackedPolys) return false;
258  if (myNonpackedPolys != src.myNonpackedPolys) return false;
259  if (myGenerateIslandAttr != src.myGenerateIslandAttr) return false;
260  if (myOutputIslandAttr != src.myOutputIslandAttr) return false;
261  if (myGenerateTargetAttr != src.myGenerateTargetAttr) return false;
262  if (myOutputTargetAttr != src.myOutputTargetAttr) return false;
263 
264  return true;
265  }
267  {
268  return !operator==(src);
269  }
277 
278 
279 
280  void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
281  {
282  myUVAttr = "uv"_sh;
283  if (true)
284  graph->evalOpParm(myUVAttr, nodeidx, "uvattrib", time, 0);
285  myUVProjPlane = 0;
286  if (true)
287  graph->evalOpParm(myUVProjPlane, nodeidx, "projplane", time, 0);
288  myGroup = ""_sh;
289  if (true)
290  graph->evalOpParm(myGroup, nodeidx, "group", time, 0);
291  mySeparatorEdges = ""_sh;
292  if (true)
293  graph->evalOpParm(mySeparatorEdges, nodeidx, "separatoredges", time, 0);
294  myUseIslandAttr = false;
295  if (true)
296  graph->evalOpParm(myUseIslandAttr, nodeidx, "useislandattr", time, 0);
297  myIslandAttr = "island"_sh;
298  if (true && ( (true&&!(((getUseIslandAttr()==0)))) ) )
299  graph->evalOpParm(myIslandAttr, nodeidx, "islandattr", time, 0);
300  myUseTargetAttr = false;
301  if (true)
302  graph->evalOpParm(myUseTargetAttr, nodeidx, "usetargetattr", time, 0);
303  myTargetAttr = "udim"_sh;
304  if (true && ( (true&&!(((getUseTargetAttr()==0)))) ) )
305  graph->evalOpParm(myTargetAttr, nodeidx, "targetattr", time, 0);
306  myTargetOverrides = ""_sh;
307  if (true)
308  graph->evalOpParm(myTargetOverrides, nodeidx, "targetoverrides", time, 0);
309  myUseIslandScaleAttr = false;
310  if (true)
311  graph->evalOpParm(myUseIslandScaleAttr, nodeidx, "useislandscaleattr", time, 0);
312  myIslandScaleAttr = "iscale"_sh;
313  if (true && ( (true&&!(((getUseIslandScaleAttr()==0)))) ) )
314  graph->evalOpParm(myIslandScaleAttr, nodeidx, "islandscaleattr", time, 0);
315  myScaleOverrides = ""_sh;
316  if (true)
317  graph->evalOpParm(myScaleOverrides, nodeidx, "scaleoverrides", time, 0);
318  myUseIslandOffsetAttr = false;
319  if (true)
320  graph->evalOpParm(myUseIslandOffsetAttr, nodeidx, "useislandsetattr", time, 0);
321  myIslandOffsetAttr = "ioffset"_sh;
322  if (true && ( (true&&!(((getUseIslandOffsetAttr()==0)))) ) )
323  graph->evalOpParm(myIslandOffsetAttr, nodeidx, "islandoffsetattr", time, 0);
324  myOffsetOverrides = ""_sh;
325  if (true)
326  graph->evalOpParm(myOffsetOverrides, nodeidx, "offsetoverrides", time, 0);
327  myCorrectAreas = false;
328  if (true)
329  graph->evalOpParm(myCorrectAreas, nodeidx, "correctareas", time, 0);
330  myAxisAlignment = 1;
331  if (true)
332  graph->evalOpParm(myAxisAlignment, nodeidx, "axisalignislands", time, 0);
333  myScaling = 0;
334  if (true)
335  graph->evalOpParm(myScaling, nodeidx, "scaling", time, 0);
336  myScale = 1;
337  if (true && ( (true&&!(((int64(getScaling())!=1)))) ) )
338  graph->evalOpParm(myScale, nodeidx, "scale", time, 0);
339  myRotationStep = 0;
340  if (true)
341  graph->evalOpParm(myRotationStep, nodeidx, "rotstep", time, 0);
342  myCircleDivs = 1;
343  if (true && ( (true&&!(((int64(getRotationStep())!=7)))) ) )
344  graph->evalOpParm(myCircleDivs, nodeidx, "circledivs", time, 0);
345  myPackBetween = false;
346  if (true)
347  graph->evalOpParm(myPackBetween, nodeidx, "packbetween", time, 0);
348  myPackInCavities = true;
349  if (true)
350  graph->evalOpParm(myPackInCavities, nodeidx, "packincavities", time, 0);
351  myPadding = 1;
352  if (true)
353  graph->evalOpParm(myPadding, nodeidx, "padding", time, 0);
354  myPadBoundaries = false;
355  if (true)
356  graph->evalOpParm(myPadBoundaries, nodeidx, "paddingboundary", time, 0);
357  myExpandPadding = false;
358  if (true)
359  graph->evalOpParm(myExpandPadding, nodeidx, "expandpadding", time, 0);
360  myIterations = 1;
361  if (true)
362  graph->evalOpParm(myIterations, nodeidx, "iterations", time, 0);
363  myResolution = 2;
364  if (true)
365  graph->evalOpParm(myResolution, nodeidx, "resolution", time, 0);
366  myCustomResolution = 1024;
367  if (true && ( (true&&!(((int64(getResolution())!=5)))) ) )
368  graph->evalOpParm(myCustomResolution, nodeidx, "customresolution", time, 0);
369  myConnectivityTolerance = 1e-05;
370  if (true)
371  graph->evalOpParm(myConnectivityTolerance, nodeidx, "uvtolerance", time, 0);
372  myScaleTolerance = 0.005;
373  if (true && ( (true&&!(((int64(getScaling())==1)))) ) )
374  graph->evalOpParm(myScaleTolerance, nodeidx, "scaletolerance", time, 0);
375  myRandSeed = 5489;
376  if (true && ( (true&&!(((int64(getIterations())==1)))) ) )
377  graph->evalOpParm(myRandSeed, nodeidx, "randseed", time, 0);
378  myTargetType = 0;
379  if (true)
380  graph->evalOpParm(myTargetType, nodeidx, "targettype", time, 0);
381  myUseDefaultTarget = false;
382  if (true && ( (true&&!(((int64(getTargetType())==1)))) ) )
383  graph->evalOpParm(myUseDefaultTarget, nodeidx, "usedefaulttarget", time, 0);
384  myDefaultTarget = 0;
385  if (true && ( (true&&!(((getUseDefaultTarget()==0))||((int64(getTargetType())==1)))) ) )
386  graph->evalOpParm(myDefaultTarget, nodeidx, "defaulttarget", time, 0);
387  myUseDefaultUdimTarget = false;
388  if (true && ( (true&&!(((int64(getTargetType())!=1)))) ) )
389  graph->evalOpParm(myUseDefaultUdimTarget, nodeidx, "usedefaultudimtarget", time, 0);
390  myDefaultUdimTarget = 1001;
391  if (true && ( (true&&!(((getUseDefaultUdimTarget()==0))||((int64(getTargetType())!=1)))) ) )
392  graph->evalOpParm(myDefaultUdimTarget, nodeidx, "defaultudimtarget", time, 0);
393  if (true && ( (!(((int64(getTargetType())!=0))||((int64(getTargetType())!=0)))) ) )
394  {
395  int64 length = 0;
396  graph->evalOpParm(length, nodeidx, "rects", time, 0);
397  if (length < 0) length = 0;
398  myRects.setSize(length);
399  for (exint i = 0; i < length; i++)
400  {
401  int parmidx[1];
402  int offsets[1];
403  parmidx[0] = i+0;
404  offsets[0] = 0;
405  auto && _curentry = myRects(i);
406  (void) _curentry;
407  _curentry.rect_use = true;
408  if (true && ( (!(((int64(getTargetType())!=0))||((int64(getTargetType())!=0)))) ) && ( (true&&!(((int64(getTargetType())!=0)))) ) )
409  graph->evalOpParmInst(_curentry.rect_use, nodeidx, "rect_use#", parmidx, offsets, time, 0, 2-1);
410  _curentry.rect_center = UT_Vector2D(0.5,0.5);
411  if (true && ( (!(((int64(getTargetType())!=0))||((int64(getTargetType())!=0)))) ) && ( (true&&!(((int64(getTargetType())!=0))||((_curentry.rect_use==0)))) ) )
412  graph->evalOpParmInst(_curentry.rect_center, nodeidx, "rect_center#", parmidx, offsets, time, 0, 2-1);
413  _curentry.rect_size = UT_Vector2D(1,1);
414  if (true && ( (!(((int64(getTargetType())!=0))||((int64(getTargetType())!=0)))) ) && ( (true&&!(((int64(getTargetType())!=0))||((_curentry.rect_use==0)))) ) )
415  graph->evalOpParmInst(_curentry.rect_size, nodeidx, "rect_size#", parmidx, offsets, time, 0, 2-1);
416 
417  }
418  }
419  else
420  myRects.clear();
421  myTileSize = UT_Vector2D(1,1);
422  if (true && ( (true&&!(((int64(getTargetType())!=1)))) ) )
423  graph->evalOpParm(myTileSize, nodeidx, "tilesize", time, 0);
424  myNumColumns = 10;
425  if (true && ( (true&&!(((int64(getTargetType())!=1)))) ) )
426  graph->evalOpParm(myNumColumns, nodeidx, "numcolumns", time, 0);
427  myStartingUdim = 1001;
428  if (true && ( (true&&!(((int64(getTargetType())!=1)))) ) )
429  graph->evalOpParm(myStartingUdim, nodeidx, "startingudim", time, 0);
430  myTargetUVAttr = "uv"_sh;
431  if (true && ( (true&&!(((int64(getTargetType())!=2))||(((graph->getInput(nodeidx,1)>=0)==0)))) ) )
432  graph->evalOpParm(myTargetUVAttr, nodeidx, "targetuvattrib", time, 0);
433  myTargetProjPlane = 0;
434  if (true && ( (true&&!(((int64(getTargetType())!=2))||(((graph->getInput(nodeidx,1)>=0)==0)))) ) )
435  graph->evalOpParm(myTargetProjPlane, nodeidx, "targetprojplane", time, 0);
436  myTargetGroup = ""_sh;
437  if (true && ( (true&&!((((graph->getInput(nodeidx,1)>=0)==0))||((int64(getTargetType())!=2)))) ) )
438  graph->evalOpParm(myTargetGroup, nodeidx, "targetgroup", time, 0);
439  myTargetSeparatorEdges = ""_sh;
440  if (true && ( (true&&!(((int64(getTargetType())!=2))||(((graph->getInput(nodeidx,1)>=0)==0))||((int64(getTargetType())!=2)))) ) )
441  graph->evalOpParm(myTargetSeparatorEdges, nodeidx, "targetseparatoredges", time, 0);
442  myUseTargetIslandAttr = false;
443  if (true && ( (true&&!(((int64(getTargetType())!=2))||(((graph->getInput(nodeidx,1)>=0)==0))||((int64(getTargetType())!=2)))) ) )
444  graph->evalOpParm(myUseTargetIslandAttr, nodeidx, "usetargetislandattr", time, 0);
445  myTargetIslandAttr = "targetisland"_sh;
446  if (true && ( (true&&!(((int64(getTargetType())!=2))||((getUseTargetIslandAttr()==0))||((int64(getTargetType())!=2)))) ) )
447  graph->evalOpParm(myTargetIslandAttr, nodeidx, "targetislandattr", time, 0);
448  myStackIslands = false;
449  if (true)
450  graph->evalOpParm(myStackIslands, nodeidx, "stackislands", time, 0);
451  myStackMirrored = false;
452  if (true && ( (true&&!(((getStackIslands()==0)))) ) )
453  graph->evalOpParm(myStackMirrored, nodeidx, "invertedoverlays", time, 0);
454  myStackOnNonGroup = false;
455  if (true && ( (true&&!(((getStackIslands()==0)))) ) )
456  graph->evalOpParm(myStackOnNonGroup, nodeidx, "stackonnongroup", time, 0);
457  myStackingLengthTolerance = 0.02;
458  if (true && ( (true&&!(((getStackIslands()==0)))) ) )
459  graph->evalOpParm(myStackingLengthTolerance, nodeidx, "overlaytolerance", time, 0);
460  myGenerateNonpackedPolys = false;
461  if (true)
462  graph->evalOpParm(myGenerateNonpackedPolys, nodeidx, "generatenonpackedpoly", time, 0);
463  myNonpackedPolys = "nonpacked"_sh;
464  if (true && ( (true&&!(((getGenerateNonpackedPolys()==0)))) ) )
465  graph->evalOpParm(myNonpackedPolys, nodeidx, "nonpackedpolys", time, 0);
466  myGenerateIslandAttr = false;
467  if (true)
468  graph->evalOpParm(myGenerateIslandAttr, nodeidx, "generateislandattr", time, 0);
469  myOutputIslandAttr = "island"_sh;
470  if (true && ( (true&&!(((getGenerateIslandAttr()==0)))) ) )
471  graph->evalOpParm(myOutputIslandAttr, nodeidx, "outputislandattr", time, 0);
472  myGenerateTargetAttr = false;
473  if (true)
474  graph->evalOpParm(myGenerateTargetAttr, nodeidx, "generatetargetattr", time, 0);
475  myOutputTargetAttr = "target"_sh;
476  if (true && ( (true&&!(((getGenerateTargetAttr()==0)))) ) )
477  graph->evalOpParm(myOutputTargetAttr, nodeidx, "outputtargetattr", time, 0);
478 
479  }
480 
481 
482  void loadFromOpSubclass(const LoadParms &loadparms) override
483  {
484  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
485  }
486 
487 
488  void copyFrom(const SOP_NodeParms *src) override
489  {
490  *this = *((const SOP_UVLayout_3_0Parms *)src);
491  }
492 
493  template <typename T>
494  void
495  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
496  {
497  if (idx.size() < 1)
498  return;
499  UT_ASSERT(idx.size() == instance.size()+1);
500  if (idx.size() != instance.size()+1)
501  return;
502  switch (idx[0])
503  {
504  case 0:
505  coerceValue(value, myUVAttr);
506  break;
507  case 1:
508  coerceValue(value, myUVProjPlane);
509  break;
510  case 2:
511  coerceValue(value, myGroup);
512  break;
513  case 3:
514  coerceValue(value, mySeparatorEdges);
515  break;
516  case 4:
517  coerceValue(value, myUseIslandAttr);
518  break;
519  case 5:
520  coerceValue(value, myIslandAttr);
521  break;
522  case 6:
523  coerceValue(value, myUseTargetAttr);
524  break;
525  case 7:
526  coerceValue(value, myTargetAttr);
527  break;
528  case 8:
529  coerceValue(value, myTargetOverrides);
530  break;
531  case 9:
532  coerceValue(value, myUseIslandScaleAttr);
533  break;
534  case 10:
535  coerceValue(value, myIslandScaleAttr);
536  break;
537  case 11:
538  coerceValue(value, myScaleOverrides);
539  break;
540  case 12:
541  coerceValue(value, myUseIslandOffsetAttr);
542  break;
543  case 13:
544  coerceValue(value, myIslandOffsetAttr);
545  break;
546  case 14:
547  coerceValue(value, myOffsetOverrides);
548  break;
549  case 15:
550  coerceValue(value, myCorrectAreas);
551  break;
552  case 16:
553  coerceValue(value, myAxisAlignment);
554  break;
555  case 17:
556  coerceValue(value, myScaling);
557  break;
558  case 18:
559  coerceValue(value, myScale);
560  break;
561  case 19:
562  coerceValue(value, myRotationStep);
563  break;
564  case 20:
565  coerceValue(value, myCircleDivs);
566  break;
567  case 21:
568  coerceValue(value, myPackBetween);
569  break;
570  case 22:
571  coerceValue(value, myPackInCavities);
572  break;
573  case 23:
574  coerceValue(value, myPadding);
575  break;
576  case 24:
577  coerceValue(value, myPadBoundaries);
578  break;
579  case 25:
580  coerceValue(value, myExpandPadding);
581  break;
582  case 26:
583  coerceValue(value, myIterations);
584  break;
585  case 27:
586  coerceValue(value, myResolution);
587  break;
588  case 28:
589  coerceValue(value, myCustomResolution);
590  break;
591  case 29:
592  coerceValue(value, myConnectivityTolerance);
593  break;
594  case 30:
595  coerceValue(value, myScaleTolerance);
596  break;
597  case 31:
598  coerceValue(value, myRandSeed);
599  break;
600  case 32:
601  coerceValue(value, myTargetType);
602  break;
603  case 33:
604  coerceValue(value, myUseDefaultTarget);
605  break;
606  case 34:
607  coerceValue(value, myDefaultTarget);
608  break;
609  case 35:
610  coerceValue(value, myUseDefaultUdimTarget);
611  break;
612  case 36:
613  coerceValue(value, myDefaultUdimTarget);
614  break;
615  case 37:
616  if (idx.size() == 1)
617  coerceValue(value, myRects.entries());
618  else if (instance[0] < myRects.entries())
619  {
620  auto && _data = myRects(instance[0]);
621  switch (idx[1])
622  {
623  case 0:
624  coerceValue(value, _data.rect_use);
625  break;
626  case 1:
627  coerceValue(value, _data.rect_center);
628  break;
629  case 2:
630  coerceValue(value, _data.rect_size);
631  break;
632 
633  }
634  }
635  break;
636  case 38:
637  coerceValue(value, myTileSize);
638  break;
639  case 39:
640  coerceValue(value, myNumColumns);
641  break;
642  case 40:
643  coerceValue(value, myStartingUdim);
644  break;
645  case 41:
646  coerceValue(value, myTargetUVAttr);
647  break;
648  case 42:
649  coerceValue(value, myTargetProjPlane);
650  break;
651  case 43:
652  coerceValue(value, myTargetGroup);
653  break;
654  case 44:
655  coerceValue(value, myTargetSeparatorEdges);
656  break;
657  case 45:
658  coerceValue(value, myUseTargetIslandAttr);
659  break;
660  case 46:
661  coerceValue(value, myTargetIslandAttr);
662  break;
663  case 47:
664  coerceValue(value, myStackIslands);
665  break;
666  case 48:
667  coerceValue(value, myStackMirrored);
668  break;
669  case 49:
670  coerceValue(value, myStackOnNonGroup);
671  break;
672  case 50:
673  coerceValue(value, myStackingLengthTolerance);
674  break;
675  case 51:
676  coerceValue(value, myGenerateNonpackedPolys);
677  break;
678  case 52:
679  coerceValue(value, myNonpackedPolys);
680  break;
681  case 53:
682  coerceValue(value, myGenerateIslandAttr);
683  break;
684  case 54:
685  coerceValue(value, myOutputIslandAttr);
686  break;
687  case 55:
688  coerceValue(value, myGenerateTargetAttr);
689  break;
690  case 56:
691  coerceValue(value, myOutputTargetAttr);
692  break;
693 
694  }
695  }
696 
697  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
698  { doGetParmValue(idx, instance, value); }
699  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
700  { doGetParmValue(idx, instance, value); }
701  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
702  { doGetParmValue(idx, instance, value); }
703  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
704  { doGetParmValue(idx, instance, value); }
705  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
706  { doGetParmValue(idx, instance, value); }
707  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
708  { doGetParmValue(idx, instance, value); }
709  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
710  { doGetParmValue(idx, instance, value); }
711  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
712  { doGetParmValue(idx, instance, value); }
713  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
714  { doGetParmValue(idx, instance, value); }
715  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
716  { doGetParmValue(idx, instance, value); }
717  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
718  { doGetParmValue(idx, instance, value); }
719 
720  template <typename T>
721  void
722  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
723  {
724  if (idx.size() < 1)
725  return;
726  UT_ASSERT(idx.size() == instance.size()+1);
727  if (idx.size() != instance.size()+1)
728  return;
729  switch (idx[0])
730  {
731  case 0:
732  coerceValue(myUVAttr, ( ( value ) ));
733  break;
734  case 1:
735  coerceValue(myUVProjPlane, clampMinValue(0, clampMaxValue(2, value ) ));
736  break;
737  case 2:
738  coerceValue(myGroup, ( ( value ) ));
739  break;
740  case 3:
741  coerceValue(mySeparatorEdges, ( ( value ) ));
742  break;
743  case 4:
744  coerceValue(myUseIslandAttr, ( ( value ) ));
745  break;
746  case 5:
747  coerceValue(myIslandAttr, ( ( value ) ));
748  break;
749  case 6:
750  coerceValue(myUseTargetAttr, ( ( value ) ));
751  break;
752  case 7:
753  coerceValue(myTargetAttr, ( ( value ) ));
754  break;
755  case 8:
756  coerceValue(myTargetOverrides, ( ( value ) ));
757  break;
758  case 9:
759  coerceValue(myUseIslandScaleAttr, ( ( value ) ));
760  break;
761  case 10:
762  coerceValue(myIslandScaleAttr, ( ( value ) ));
763  break;
764  case 11:
765  coerceValue(myScaleOverrides, ( ( value ) ));
766  break;
767  case 12:
768  coerceValue(myUseIslandOffsetAttr, ( ( value ) ));
769  break;
770  case 13:
771  coerceValue(myIslandOffsetAttr, ( ( value ) ));
772  break;
773  case 14:
774  coerceValue(myOffsetOverrides, ( ( value ) ));
775  break;
776  case 15:
777  coerceValue(myCorrectAreas, ( ( value ) ));
778  break;
779  case 16:
780  coerceValue(myAxisAlignment, clampMinValue(0, clampMaxValue(2, value ) ));
781  break;
782  case 17:
783  coerceValue(myScaling, clampMinValue(0, clampMaxValue(1, value ) ));
784  break;
785  case 18:
786  coerceValue(myScale, clampMinValue(0, ( value ) ));
787  break;
788  case 19:
789  coerceValue(myRotationStep, clampMinValue(0, clampMaxValue(7, value ) ));
790  break;
791  case 20:
792  coerceValue(myCircleDivs, clampMinValue(1, ( value ) ));
793  break;
794  case 21:
795  coerceValue(myPackBetween, ( ( value ) ));
796  break;
797  case 22:
798  coerceValue(myPackInCavities, ( ( value ) ));
799  break;
800  case 23:
801  coerceValue(myPadding, clampMinValue(0, ( value ) ));
802  break;
803  case 24:
804  coerceValue(myPadBoundaries, ( ( value ) ));
805  break;
806  case 25:
807  coerceValue(myExpandPadding, ( ( value ) ));
808  break;
809  case 26:
810  coerceValue(myIterations, clampMinValue(1, ( value ) ));
811  break;
812  case 27:
813  coerceValue(myResolution, clampMinValue(0, clampMaxValue(5, value ) ));
814  break;
815  case 28:
816  coerceValue(myCustomResolution, clampMinValue(128, clampMaxValue(32768, value ) ));
817  break;
818  case 29:
819  coerceValue(myConnectivityTolerance, clampMinValue(0, ( value ) ));
820  break;
821  case 30:
822  coerceValue(myScaleTolerance, ( clampMaxValue(-15, value ) ));
823  break;
824  case 31:
825  coerceValue(myRandSeed, clampMinValue(0, ( value ) ));
826  break;
827  case 32:
828  coerceValue(myTargetType, clampMinValue(0, clampMaxValue(2, value ) ));
829  break;
830  case 33:
831  coerceValue(myUseDefaultTarget, ( ( value ) ));
832  break;
833  case 34:
834  coerceValue(myDefaultTarget, clampMinValue(0, ( value ) ));
835  break;
836  case 35:
837  coerceValue(myUseDefaultUdimTarget, ( ( value ) ));
838  break;
839  case 36:
840  coerceValue(myDefaultUdimTarget, clampMinValue(1001, ( value ) ));
841  break;
842  case 37:
843  if (idx.size() == 1)
844  {
845  exint newsize;
846  coerceValue(newsize, value);
847  if (newsize < 0) newsize = 0;
848  myRects.setSize(newsize);
849  }
850  else
851  {
852  if (instance[0] < 0)
853  return;
854  myRects.setSizeIfNeeded(instance[0]+1);
855  auto && _data = myRects(instance[0]);
856  switch (idx[1])
857  {
858  case 0:
859  coerceValue(_data.rect_use, value);
860  break;
861  case 1:
862  coerceValue(_data.rect_center, value);
863  break;
864  case 2:
865  coerceValue(_data.rect_size, value);
866  break;
867 
868  }
869  }
870  break;
871  case 38:
872  coerceValue(myTileSize, ( clampMaxValue(-5, value ) ));
873  break;
874  case 39:
875  coerceValue(myNumColumns, clampMinValue(1, ( value ) ));
876  break;
877  case 40:
878  coerceValue(myStartingUdim, ( ( value ) ));
879  break;
880  case 41:
881  coerceValue(myTargetUVAttr, ( ( value ) ));
882  break;
883  case 42:
884  coerceValue(myTargetProjPlane, clampMinValue(0, clampMaxValue(2, value ) ));
885  break;
886  case 43:
887  coerceValue(myTargetGroup, ( ( value ) ));
888  break;
889  case 44:
890  coerceValue(myTargetSeparatorEdges, ( ( value ) ));
891  break;
892  case 45:
893  coerceValue(myUseTargetIslandAttr, ( ( value ) ));
894  break;
895  case 46:
896  coerceValue(myTargetIslandAttr, ( ( value ) ));
897  break;
898  case 47:
899  coerceValue(myStackIslands, ( ( value ) ));
900  break;
901  case 48:
902  coerceValue(myStackMirrored, ( ( value ) ));
903  break;
904  case 49:
905  coerceValue(myStackOnNonGroup, ( ( value ) ));
906  break;
907  case 50:
908  coerceValue(myStackingLengthTolerance, clampMinValue(0, ( value ) ));
909  break;
910  case 51:
911  coerceValue(myGenerateNonpackedPolys, ( ( value ) ));
912  break;
913  case 52:
914  coerceValue(myNonpackedPolys, ( ( value ) ));
915  break;
916  case 53:
917  coerceValue(myGenerateIslandAttr, ( ( value ) ));
918  break;
919  case 54:
920  coerceValue(myOutputIslandAttr, ( ( value ) ));
921  break;
922  case 55:
923  coerceValue(myGenerateTargetAttr, ( ( value ) ));
924  break;
925  case 56:
926  coerceValue(myOutputTargetAttr, ( ( value ) ));
927  break;
928 
929  }
930  }
931 
932  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
933  { doSetParmValue(idx, instance, value); }
934  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
935  { doSetParmValue(idx, instance, value); }
936  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
937  { doSetParmValue(idx, instance, value); }
938  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
939  { doSetParmValue(idx, instance, value); }
940  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
941  { doSetParmValue(idx, instance, value); }
942  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
943  { doSetParmValue(idx, instance, value); }
944  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
945  { doSetParmValue(idx, instance, value); }
946  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
947  { doSetParmValue(idx, instance, value); }
948  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
949  { doSetParmValue(idx, instance, value); }
950  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
951  { doSetParmValue(idx, instance, value); }
952  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
953  { doSetParmValue(idx, instance, value); }
954 
955  exint getNestNumParms(TempIndex idx) const override
956  {
957  if (idx.size() == 0)
958  return 57;
959  switch (idx[0])
960  {
961  case 37:
962  return 3;
963 
964  }
965  // Invalid
966  return 0;
967  }
968 
969  const char *getNestParmName(TempIndex fieldnum) const override
970  {
971  if (fieldnum.size() < 1)
972  return 0;
973  switch (fieldnum[0])
974  {
975  case 0:
976  return "uvattrib";
977  case 1:
978  return "projplane";
979  case 2:
980  return "group";
981  case 3:
982  return "separatoredges";
983  case 4:
984  return "useislandattr";
985  case 5:
986  return "islandattr";
987  case 6:
988  return "usetargetattr";
989  case 7:
990  return "targetattr";
991  case 8:
992  return "targetoverrides";
993  case 9:
994  return "useislandscaleattr";
995  case 10:
996  return "islandscaleattr";
997  case 11:
998  return "scaleoverrides";
999  case 12:
1000  return "useislandsetattr";
1001  case 13:
1002  return "islandoffsetattr";
1003  case 14:
1004  return "offsetoverrides";
1005  case 15:
1006  return "correctareas";
1007  case 16:
1008  return "axisalignislands";
1009  case 17:
1010  return "scaling";
1011  case 18:
1012  return "scale";
1013  case 19:
1014  return "rotstep";
1015  case 20:
1016  return "circledivs";
1017  case 21:
1018  return "packbetween";
1019  case 22:
1020  return "packincavities";
1021  case 23:
1022  return "padding";
1023  case 24:
1024  return "paddingboundary";
1025  case 25:
1026  return "expandpadding";
1027  case 26:
1028  return "iterations";
1029  case 27:
1030  return "resolution";
1031  case 28:
1032  return "customresolution";
1033  case 29:
1034  return "uvtolerance";
1035  case 30:
1036  return "scaletolerance";
1037  case 31:
1038  return "randseed";
1039  case 32:
1040  return "targettype";
1041  case 33:
1042  return "usedefaulttarget";
1043  case 34:
1044  return "defaulttarget";
1045  case 35:
1046  return "usedefaultudimtarget";
1047  case 36:
1048  return "defaultudimtarget";
1049  case 37:
1050  if (fieldnum.size() == 1)
1051  return "rects";
1052  switch (fieldnum[1])
1053  {
1054  case 0:
1055  return "rect_use#";
1056  case 1:
1057  return "rect_center#";
1058  case 2:
1059  return "rect_size#";
1060 
1061  }
1062  return 0;
1063  case 38:
1064  return "tilesize";
1065  case 39:
1066  return "numcolumns";
1067  case 40:
1068  return "startingudim";
1069  case 41:
1070  return "targetuvattrib";
1071  case 42:
1072  return "targetprojplane";
1073  case 43:
1074  return "targetgroup";
1075  case 44:
1076  return "targetseparatoredges";
1077  case 45:
1078  return "usetargetislandattr";
1079  case 46:
1080  return "targetislandattr";
1081  case 47:
1082  return "stackislands";
1083  case 48:
1084  return "invertedoverlays";
1085  case 49:
1086  return "stackonnongroup";
1087  case 50:
1088  return "overlaytolerance";
1089  case 51:
1090  return "generatenonpackedpoly";
1091  case 52:
1092  return "nonpackedpolys";
1093  case 53:
1094  return "generateislandattr";
1095  case 54:
1096  return "outputislandattr";
1097  case 55:
1098  return "generatetargetattr";
1099  case 56:
1100  return "outputtargetattr";
1101 
1102  }
1103  return 0;
1104  }
1105 
1106  ParmType getNestParmType(TempIndex fieldnum) const override
1107  {
1108  if (fieldnum.size() < 1)
1109  return PARM_UNSUPPORTED;
1110  switch (fieldnum[0])
1111  {
1112  case 0:
1113  return PARM_STRING;
1114  case 1:
1115  return PARM_INTEGER;
1116  case 2:
1117  return PARM_STRING;
1118  case 3:
1119  return PARM_STRING;
1120  case 4:
1121  return PARM_INTEGER;
1122  case 5:
1123  return PARM_STRING;
1124  case 6:
1125  return PARM_INTEGER;
1126  case 7:
1127  return PARM_STRING;
1128  case 8:
1129  return PARM_STRING;
1130  case 9:
1131  return PARM_INTEGER;
1132  case 10:
1133  return PARM_STRING;
1134  case 11:
1135  return PARM_STRING;
1136  case 12:
1137  return PARM_INTEGER;
1138  case 13:
1139  return PARM_STRING;
1140  case 14:
1141  return PARM_STRING;
1142  case 15:
1143  return PARM_INTEGER;
1144  case 16:
1145  return PARM_INTEGER;
1146  case 17:
1147  return PARM_INTEGER;
1148  case 18:
1149  return PARM_FLOAT;
1150  case 19:
1151  return PARM_INTEGER;
1152  case 20:
1153  return PARM_INTEGER;
1154  case 21:
1155  return PARM_INTEGER;
1156  case 22:
1157  return PARM_INTEGER;
1158  case 23:
1159  return PARM_INTEGER;
1160  case 24:
1161  return PARM_INTEGER;
1162  case 25:
1163  return PARM_INTEGER;
1164  case 26:
1165  return PARM_INTEGER;
1166  case 27:
1167  return PARM_INTEGER;
1168  case 28:
1169  return PARM_INTEGER;
1170  case 29:
1171  return PARM_FLOAT;
1172  case 30:
1173  return PARM_FLOAT;
1174  case 31:
1175  return PARM_INTEGER;
1176  case 32:
1177  return PARM_INTEGER;
1178  case 33:
1179  return PARM_INTEGER;
1180  case 34:
1181  return PARM_INTEGER;
1182  case 35:
1183  return PARM_INTEGER;
1184  case 36:
1185  return PARM_INTEGER;
1186  case 37:
1187  if (fieldnum.size() == 1)
1188  return PARM_MULTIPARM;
1189  switch (fieldnum[1])
1190  {
1191  case 0:
1192  return PARM_INTEGER;
1193  case 1:
1194  return PARM_VECTOR2;
1195  case 2:
1196  return PARM_VECTOR2;
1197 
1198  }
1199  return PARM_UNSUPPORTED;
1200  case 38:
1201  return PARM_VECTOR2;
1202  case 39:
1203  return PARM_INTEGER;
1204  case 40:
1205  return PARM_INTEGER;
1206  case 41:
1207  return PARM_STRING;
1208  case 42:
1209  return PARM_INTEGER;
1210  case 43:
1211  return PARM_STRING;
1212  case 44:
1213  return PARM_STRING;
1214  case 45:
1215  return PARM_INTEGER;
1216  case 46:
1217  return PARM_STRING;
1218  case 47:
1219  return PARM_INTEGER;
1220  case 48:
1221  return PARM_INTEGER;
1222  case 49:
1223  return PARM_INTEGER;
1224  case 50:
1225  return PARM_FLOAT;
1226  case 51:
1227  return PARM_INTEGER;
1228  case 52:
1229  return PARM_STRING;
1230  case 53:
1231  return PARM_INTEGER;
1232  case 54:
1233  return PARM_STRING;
1234  case 55:
1235  return PARM_INTEGER;
1236  case 56:
1237  return PARM_STRING;
1238 
1239  }
1240  return PARM_UNSUPPORTED;
1241  }
1242 
1243  // Boiler plate to load individual types.
1244  static void loadData(UT_IStream &is, int64 &v)
1245  { is.bread(&v, 1); }
1246  static void loadData(UT_IStream &is, bool &v)
1247  { int64 iv; is.bread(&iv, 1); v = iv; }
1248  static void loadData(UT_IStream &is, fpreal64 &v)
1249  { is.bread<fpreal64>(&v, 1); }
1250  static void loadData(UT_IStream &is, UT_Vector2D &v)
1251  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
1252  static void loadData(UT_IStream &is, UT_Vector3D &v)
1253  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1254  is.bread<fpreal64>(&v.z(), 1); }
1255  static void loadData(UT_IStream &is, UT_Vector4D &v)
1256  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1257  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
1258  static void loadData(UT_IStream &is, UT_Matrix2D &v)
1259  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
1260  static void loadData(UT_IStream &is, UT_Matrix3D &v)
1261  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
1262  static void loadData(UT_IStream &is, UT_Matrix4D &v)
1263  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
1264  static void loadData(UT_IStream &is, UT_Vector2I &v)
1265  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
1266  static void loadData(UT_IStream &is, UT_Vector3I &v)
1267  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1268  is.bread<int64>(&v.z(), 1); }
1269  static void loadData(UT_IStream &is, UT_Vector4I &v)
1270  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1271  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
1273  { is.bread(v); }
1275  { UT_StringHolder rampdata;
1276  loadData(is, rampdata);
1277  if (rampdata.isstring())
1278  {
1279  v.reset(new UT_Ramp());
1280  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
1281  v->load(istr);
1282  }
1283  else v.reset();
1284  }
1287  loadData(is, data);
1288  if (data.isstring())
1289  {
1290  // Find the data type.
1291  const char *colon = UT_StringWrap(data).findChar(':');
1292  if (colon)
1293  {
1294  int typelen = colon - data.buffer();
1296  type.strncpy(data.buffer(), typelen);
1297  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1298 
1299  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1300  }
1301  }
1302  else v.reset();
1303  }
1304 
1305  static void saveData(std::ostream &os, int64 v)
1306  { UTwrite(os, &v); }
1307  static void saveData(std::ostream &os, bool v)
1308  { int64 iv = v; UTwrite(os, &iv); }
1309  static void saveData(std::ostream &os, fpreal64 v)
1310  { UTwrite<fpreal64>(os, &v); }
1311  static void saveData(std::ostream &os, UT_Vector2D v)
1312  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1313  static void saveData(std::ostream &os, UT_Vector3D v)
1314  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1315  UTwrite<fpreal64>(os, &v.z()); }
1316  static void saveData(std::ostream &os, UT_Vector4D v)
1317  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1318  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1319  static void saveData(std::ostream &os, UT_Matrix2D v)
1321  static void saveData(std::ostream &os, UT_Matrix3D v)
1323  static void saveData(std::ostream &os, UT_Matrix4D v)
1325  static void saveData(std::ostream &os, UT_StringHolder s)
1326  { UT_StringWrap(s).saveBinary(os); }
1327  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1329  UT_OStringStream ostr;
1330  if (s) s->save(ostr);
1331  result = ostr.str();
1332  saveData(os, result);
1333  }
1334  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1336  UT_OStringStream ostr;
1337  if (s)
1338  {
1339  ostr << s->getDataTypeToken();
1340  ostr << ":";
1341  s->saveBinary(ostr);
1342  }
1343  result = ostr.str();
1344  saveData(os, result);
1345  }
1346 
1347 
1348  void save(std::ostream &os) const
1349  {
1350  int32 v = version();
1351  UTwrite(os, &v);
1352  saveData(os, myUVAttr);
1353  saveData(os, myUVProjPlane);
1354  saveData(os, myGroup);
1355  saveData(os, mySeparatorEdges);
1356  saveData(os, myUseIslandAttr);
1357  saveData(os, myIslandAttr);
1358  saveData(os, myUseTargetAttr);
1359  saveData(os, myTargetAttr);
1360  saveData(os, myTargetOverrides);
1361  saveData(os, myUseIslandScaleAttr);
1362  saveData(os, myIslandScaleAttr);
1363  saveData(os, myScaleOverrides);
1364  saveData(os, myUseIslandOffsetAttr);
1365  saveData(os, myIslandOffsetAttr);
1366  saveData(os, myOffsetOverrides);
1367  saveData(os, myCorrectAreas);
1368  saveData(os, myAxisAlignment);
1369  saveData(os, myScaling);
1370  saveData(os, myScale);
1371  saveData(os, myRotationStep);
1372  saveData(os, myCircleDivs);
1373  saveData(os, myPackBetween);
1374  saveData(os, myPackInCavities);
1375  saveData(os, myPadding);
1376  saveData(os, myPadBoundaries);
1377  saveData(os, myExpandPadding);
1378  saveData(os, myIterations);
1379  saveData(os, myResolution);
1380  saveData(os, myCustomResolution);
1381  saveData(os, myConnectivityTolerance);
1382  saveData(os, myScaleTolerance);
1383  saveData(os, myRandSeed);
1384  saveData(os, myTargetType);
1385  saveData(os, myUseDefaultTarget);
1386  saveData(os, myDefaultTarget);
1387  saveData(os, myUseDefaultUdimTarget);
1388  saveData(os, myDefaultUdimTarget);
1389  {
1390  int64 length = myRects.entries();
1391  UTwrite(os, &length);
1392  for (exint i = 0; i < length; i++)
1393  {
1394  auto && _curentry = myRects(i);
1395  (void) _curentry;
1396  saveData(os, _curentry.rect_use);
1397  saveData(os, _curentry.rect_center);
1398  saveData(os, _curentry.rect_size);
1399 
1400  }
1401  }
1402  saveData(os, myTileSize);
1403  saveData(os, myNumColumns);
1404  saveData(os, myStartingUdim);
1405  saveData(os, myTargetUVAttr);
1406  saveData(os, myTargetProjPlane);
1407  saveData(os, myTargetGroup);
1408  saveData(os, myTargetSeparatorEdges);
1409  saveData(os, myUseTargetIslandAttr);
1410  saveData(os, myTargetIslandAttr);
1411  saveData(os, myStackIslands);
1412  saveData(os, myStackMirrored);
1413  saveData(os, myStackOnNonGroup);
1414  saveData(os, myStackingLengthTolerance);
1415  saveData(os, myGenerateNonpackedPolys);
1416  saveData(os, myNonpackedPolys);
1417  saveData(os, myGenerateIslandAttr);
1418  saveData(os, myOutputIslandAttr);
1419  saveData(os, myGenerateTargetAttr);
1420  saveData(os, myOutputTargetAttr);
1421 
1422  }
1423 
1424  bool load(UT_IStream &is)
1425  {
1426  int32 v;
1427  is.bread(&v, 1);
1428  if (version() != v)
1429  {
1430  // Fail incompatible versions
1431  return false;
1432  }
1433  loadData(is, myUVAttr);
1434  loadData(is, myUVProjPlane);
1435  loadData(is, myGroup);
1436  loadData(is, mySeparatorEdges);
1437  loadData(is, myUseIslandAttr);
1438  loadData(is, myIslandAttr);
1439  loadData(is, myUseTargetAttr);
1440  loadData(is, myTargetAttr);
1441  loadData(is, myTargetOverrides);
1442  loadData(is, myUseIslandScaleAttr);
1443  loadData(is, myIslandScaleAttr);
1444  loadData(is, myScaleOverrides);
1445  loadData(is, myUseIslandOffsetAttr);
1446  loadData(is, myIslandOffsetAttr);
1447  loadData(is, myOffsetOverrides);
1448  loadData(is, myCorrectAreas);
1449  loadData(is, myAxisAlignment);
1450  loadData(is, myScaling);
1451  loadData(is, myScale);
1452  loadData(is, myRotationStep);
1453  loadData(is, myCircleDivs);
1454  loadData(is, myPackBetween);
1455  loadData(is, myPackInCavities);
1456  loadData(is, myPadding);
1457  loadData(is, myPadBoundaries);
1458  loadData(is, myExpandPadding);
1459  loadData(is, myIterations);
1460  loadData(is, myResolution);
1461  loadData(is, myCustomResolution);
1462  loadData(is, myConnectivityTolerance);
1463  loadData(is, myScaleTolerance);
1464  loadData(is, myRandSeed);
1465  loadData(is, myTargetType);
1466  loadData(is, myUseDefaultTarget);
1467  loadData(is, myDefaultTarget);
1468  loadData(is, myUseDefaultUdimTarget);
1469  loadData(is, myDefaultUdimTarget);
1470  {
1471  int64 length;
1472  is.read(&length, 1);
1473  myRects.setSize(length);
1474  for (exint i = 0; i < length; i++)
1475  {
1476  auto && _curentry = myRects(i);
1477  (void) _curentry;
1478  loadData(is, _curentry.rect_use);
1479  loadData(is, _curentry.rect_center);
1480  loadData(is, _curentry.rect_size);
1481 
1482  }
1483  }
1484  loadData(is, myTileSize);
1485  loadData(is, myNumColumns);
1486  loadData(is, myStartingUdim);
1487  loadData(is, myTargetUVAttr);
1488  loadData(is, myTargetProjPlane);
1489  loadData(is, myTargetGroup);
1490  loadData(is, myTargetSeparatorEdges);
1491  loadData(is, myUseTargetIslandAttr);
1492  loadData(is, myTargetIslandAttr);
1493  loadData(is, myStackIslands);
1494  loadData(is, myStackMirrored);
1495  loadData(is, myStackOnNonGroup);
1496  loadData(is, myStackingLengthTolerance);
1497  loadData(is, myGenerateNonpackedPolys);
1498  loadData(is, myNonpackedPolys);
1499  loadData(is, myGenerateIslandAttr);
1500  loadData(is, myOutputIslandAttr);
1501  loadData(is, myGenerateTargetAttr);
1502  loadData(is, myOutputTargetAttr);
1503 
1504  return true;
1505  }
1506 
1507  const UT_StringHolder & getUVAttr() const { return myUVAttr; }
1508  void setUVAttr(const UT_StringHolder & val) { myUVAttr = val; }
1510  {
1511  SOP_Node *thissop = cookparms.getNode();
1512  if (!thissop) return getUVAttr();
1514  OP_Utils::evalOpParm(result, thissop, "uvattrib", cookparms.getCookTime(), 0);
1515  return result;
1516  }
1517  UVProjPlane getUVProjPlane() const { return UVProjPlane(myUVProjPlane); }
1518  void setUVProjPlane(UVProjPlane val) { myUVProjPlane = int64(val); }
1520  {
1521  SOP_Node *thissop = cookparms.getNode();
1522  if (!thissop) return getUVProjPlane();
1523  int64 result;
1524  OP_Utils::evalOpParm(result, thissop, "projplane", cookparms.getCookTime(), 0);
1525  return UVProjPlane(result);
1526  }
1527  const UT_StringHolder & getGroup() const { return myGroup; }
1528  void setGroup(const UT_StringHolder & val) { myGroup = val; }
1530  {
1531  SOP_Node *thissop = cookparms.getNode();
1532  if (!thissop) return getGroup();
1534  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
1535  return result;
1536  }
1537  const UT_StringHolder & getSeparatorEdges() const { return mySeparatorEdges; }
1538  void setSeparatorEdges(const UT_StringHolder & val) { mySeparatorEdges = val; }
1540  {
1541  SOP_Node *thissop = cookparms.getNode();
1542  if (!thissop) return getSeparatorEdges();
1544  OP_Utils::evalOpParm(result, thissop, "separatoredges", cookparms.getCookTime(), 0);
1545  return result;
1546  }
1547  bool getUseIslandAttr() const { return myUseIslandAttr; }
1548  void setUseIslandAttr(bool val) { myUseIslandAttr = val; }
1549  bool opUseIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
1550  {
1551  SOP_Node *thissop = cookparms.getNode();
1552  if (!thissop) return getUseIslandAttr();
1553  bool result;
1554  OP_Utils::evalOpParm(result, thissop, "useislandattr", cookparms.getCookTime(), 0);
1555  return result;
1556  }
1557  const UT_StringHolder & getIslandAttr() const { return myIslandAttr; }
1558  void setIslandAttr(const UT_StringHolder & val) { myIslandAttr = val; }
1560  {
1561  SOP_Node *thissop = cookparms.getNode();
1562  if (!thissop) return getIslandAttr();
1564  OP_Utils::evalOpParm(result, thissop, "islandattr", cookparms.getCookTime(), 0);
1565  return result;
1566  }
1567  bool getUseTargetAttr() const { return myUseTargetAttr; }
1568  void setUseTargetAttr(bool val) { myUseTargetAttr = val; }
1569  bool opUseTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
1570  {
1571  SOP_Node *thissop = cookparms.getNode();
1572  if (!thissop) return getUseTargetAttr();
1573  bool result;
1574  OP_Utils::evalOpParm(result, thissop, "usetargetattr", cookparms.getCookTime(), 0);
1575  return result;
1576  }
1577  const UT_StringHolder & getTargetAttr() const { return myTargetAttr; }
1578  void setTargetAttr(const UT_StringHolder & val) { myTargetAttr = val; }
1580  {
1581  SOP_Node *thissop = cookparms.getNode();
1582  if (!thissop) return getTargetAttr();
1584  OP_Utils::evalOpParm(result, thissop, "targetattr", cookparms.getCookTime(), 0);
1585  return result;
1586  }
1587  const UT_StringHolder & getTargetOverrides() const { return myTargetOverrides; }
1588  void setTargetOverrides(const UT_StringHolder & val) { myTargetOverrides = val; }
1590  {
1591  SOP_Node *thissop = cookparms.getNode();
1592  if (!thissop) return getTargetOverrides();
1594  OP_Utils::evalOpParm(result, thissop, "targetoverrides", cookparms.getCookTime(), 0);
1595  return result;
1596  }
1597  bool getUseIslandScaleAttr() const { return myUseIslandScaleAttr; }
1598  void setUseIslandScaleAttr(bool val) { myUseIslandScaleAttr = val; }
1599  bool opUseIslandScaleAttr(const SOP_NodeVerb::CookParms &cookparms) const
1600  {
1601  SOP_Node *thissop = cookparms.getNode();
1602  if (!thissop) return getUseIslandScaleAttr();
1603  bool result;
1604  OP_Utils::evalOpParm(result, thissop, "useislandscaleattr", cookparms.getCookTime(), 0);
1605  return result;
1606  }
1607  const UT_StringHolder & getIslandScaleAttr() const { return myIslandScaleAttr; }
1608  void setIslandScaleAttr(const UT_StringHolder & val) { myIslandScaleAttr = val; }
1610  {
1611  SOP_Node *thissop = cookparms.getNode();
1612  if (!thissop) return getIslandScaleAttr();
1614  OP_Utils::evalOpParm(result, thissop, "islandscaleattr", cookparms.getCookTime(), 0);
1615  return result;
1616  }
1617  const UT_StringHolder & getScaleOverrides() const { return myScaleOverrides; }
1618  void setScaleOverrides(const UT_StringHolder & val) { myScaleOverrides = val; }
1620  {
1621  SOP_Node *thissop = cookparms.getNode();
1622  if (!thissop) return getScaleOverrides();
1624  OP_Utils::evalOpParm(result, thissop, "scaleoverrides", cookparms.getCookTime(), 0);
1625  return result;
1626  }
1627  bool getUseIslandOffsetAttr() const { return myUseIslandOffsetAttr; }
1628  void setUseIslandOffsetAttr(bool val) { myUseIslandOffsetAttr = val; }
1629  bool opUseIslandOffsetAttr(const SOP_NodeVerb::CookParms &cookparms) const
1630  {
1631  SOP_Node *thissop = cookparms.getNode();
1632  if (!thissop) return getUseIslandOffsetAttr();
1633  bool result;
1634  OP_Utils::evalOpParm(result, thissop, "useislandsetattr", cookparms.getCookTime(), 0);
1635  return result;
1636  }
1637  const UT_StringHolder & getIslandOffsetAttr() const { return myIslandOffsetAttr; }
1638  void setIslandOffsetAttr(const UT_StringHolder & val) { myIslandOffsetAttr = val; }
1640  {
1641  SOP_Node *thissop = cookparms.getNode();
1642  if (!thissop) return getIslandOffsetAttr();
1644  OP_Utils::evalOpParm(result, thissop, "islandoffsetattr", cookparms.getCookTime(), 0);
1645  return result;
1646  }
1647  const UT_StringHolder & getOffsetOverrides() const { return myOffsetOverrides; }
1648  void setOffsetOverrides(const UT_StringHolder & val) { myOffsetOverrides = val; }
1650  {
1651  SOP_Node *thissop = cookparms.getNode();
1652  if (!thissop) return getOffsetOverrides();
1654  OP_Utils::evalOpParm(result, thissop, "offsetoverrides", cookparms.getCookTime(), 0);
1655  return result;
1656  }
1657  bool getCorrectAreas() const { return myCorrectAreas; }
1658  void setCorrectAreas(bool val) { myCorrectAreas = val; }
1659  bool opCorrectAreas(const SOP_NodeVerb::CookParms &cookparms) const
1660  {
1661  SOP_Node *thissop = cookparms.getNode();
1662  if (!thissop) return getCorrectAreas();
1663  bool result;
1664  OP_Utils::evalOpParm(result, thissop, "correctareas", cookparms.getCookTime(), 0);
1665  return result;
1666  }
1667  AxisAlignment getAxisAlignment() const { return AxisAlignment(myAxisAlignment); }
1668  void setAxisAlignment(AxisAlignment val) { myAxisAlignment = int64(val); }
1670  {
1671  SOP_Node *thissop = cookparms.getNode();
1672  if (!thissop) return getAxisAlignment();
1673  int64 result;
1674  OP_Utils::evalOpParm(result, thissop, "axisalignislands", cookparms.getCookTime(), 0);
1675  return AxisAlignment(result);
1676  }
1677  Scaling getScaling() const { return Scaling(myScaling); }
1678  void setScaling(Scaling val) { myScaling = int64(val); }
1680  {
1681  SOP_Node *thissop = cookparms.getNode();
1682  if (!thissop) return getScaling();
1683  int64 result;
1684  OP_Utils::evalOpParm(result, thissop, "scaling", cookparms.getCookTime(), 0);
1685  return Scaling(result);
1686  }
1687  fpreal64 getScale() const { return myScale; }
1688  void setScale(fpreal64 val) { myScale = val; }
1689  fpreal64 opScale(const SOP_NodeVerb::CookParms &cookparms) const
1690  {
1691  SOP_Node *thissop = cookparms.getNode();
1692  if (!thissop) return getScale();
1693  fpreal64 result;
1694  OP_Utils::evalOpParm(result, thissop, "scale", cookparms.getCookTime(), 0);
1695  return result;
1696  }
1697  RotationStep getRotationStep() const { return RotationStep(myRotationStep); }
1698  void setRotationStep(RotationStep val) { myRotationStep = int64(val); }
1700  {
1701  SOP_Node *thissop = cookparms.getNode();
1702  if (!thissop) return getRotationStep();
1703  int64 result;
1704  OP_Utils::evalOpParm(result, thissop, "rotstep", cookparms.getCookTime(), 0);
1705  return RotationStep(result);
1706  }
1707  int64 getCircleDivs() const { return myCircleDivs; }
1708  void setCircleDivs(int64 val) { myCircleDivs = val; }
1710  {
1711  SOP_Node *thissop = cookparms.getNode();
1712  if (!thissop) return getCircleDivs();
1713  int64 result;
1714  OP_Utils::evalOpParm(result, thissop, "circledivs", cookparms.getCookTime(), 0);
1715  return result;
1716  }
1717  bool getPackBetween() const { return myPackBetween; }
1718  void setPackBetween(bool val) { myPackBetween = val; }
1719  bool opPackBetween(const SOP_NodeVerb::CookParms &cookparms) const
1720  {
1721  SOP_Node *thissop = cookparms.getNode();
1722  if (!thissop) return getPackBetween();
1723  bool result;
1724  OP_Utils::evalOpParm(result, thissop, "packbetween", cookparms.getCookTime(), 0);
1725  return result;
1726  }
1727  bool getPackInCavities() const { return myPackInCavities; }
1728  void setPackInCavities(bool val) { myPackInCavities = val; }
1729  bool opPackInCavities(const SOP_NodeVerb::CookParms &cookparms) const
1730  {
1731  SOP_Node *thissop = cookparms.getNode();
1732  if (!thissop) return getPackInCavities();
1733  bool result;
1734  OP_Utils::evalOpParm(result, thissop, "packincavities", cookparms.getCookTime(), 0);
1735  return result;
1736  }
1737  int64 getPadding() const { return myPadding; }
1738  void setPadding(int64 val) { myPadding = val; }
1739  int64 opPadding(const SOP_NodeVerb::CookParms &cookparms) const
1740  {
1741  SOP_Node *thissop = cookparms.getNode();
1742  if (!thissop) return getPadding();
1743  int64 result;
1744  OP_Utils::evalOpParm(result, thissop, "padding", cookparms.getCookTime(), 0);
1745  return result;
1746  }
1747  bool getPadBoundaries() const { return myPadBoundaries; }
1748  void setPadBoundaries(bool val) { myPadBoundaries = val; }
1749  bool opPadBoundaries(const SOP_NodeVerb::CookParms &cookparms) const
1750  {
1751  SOP_Node *thissop = cookparms.getNode();
1752  if (!thissop) return getPadBoundaries();
1753  bool result;
1754  OP_Utils::evalOpParm(result, thissop, "paddingboundary", cookparms.getCookTime(), 0);
1755  return result;
1756  }
1757  bool getExpandPadding() const { return myExpandPadding; }
1758  void setExpandPadding(bool val) { myExpandPadding = val; }
1759  bool opExpandPadding(const SOP_NodeVerb::CookParms &cookparms) const
1760  {
1761  SOP_Node *thissop = cookparms.getNode();
1762  if (!thissop) return getExpandPadding();
1763  bool result;
1764  OP_Utils::evalOpParm(result, thissop, "expandpadding", cookparms.getCookTime(), 0);
1765  return result;
1766  }
1767  int64 getIterations() const { return myIterations; }
1768  void setIterations(int64 val) { myIterations = val; }
1770  {
1771  SOP_Node *thissop = cookparms.getNode();
1772  if (!thissop) return getIterations();
1773  int64 result;
1774  OP_Utils::evalOpParm(result, thissop, "iterations", cookparms.getCookTime(), 0);
1775  return result;
1776  }
1777  Resolution getResolution() const { return Resolution(myResolution); }
1778  void setResolution(Resolution val) { myResolution = int64(val); }
1780  {
1781  SOP_Node *thissop = cookparms.getNode();
1782  if (!thissop) return getResolution();
1783  int64 result;
1784  OP_Utils::evalOpParm(result, thissop, "resolution", cookparms.getCookTime(), 0);
1785  return Resolution(result);
1786  }
1787  int64 getCustomResolution() const { return myCustomResolution; }
1788  void setCustomResolution(int64 val) { myCustomResolution = val; }
1790  {
1791  SOP_Node *thissop = cookparms.getNode();
1792  if (!thissop) return getCustomResolution();
1793  int64 result;
1794  OP_Utils::evalOpParm(result, thissop, "customresolution", cookparms.getCookTime(), 0);
1795  return result;
1796  }
1797  fpreal64 getConnectivityTolerance() const { return myConnectivityTolerance; }
1798  void setConnectivityTolerance(fpreal64 val) { myConnectivityTolerance = val; }
1800  {
1801  SOP_Node *thissop = cookparms.getNode();
1802  if (!thissop) return getConnectivityTolerance();
1803  fpreal64 result;
1804  OP_Utils::evalOpParm(result, thissop, "uvtolerance", cookparms.getCookTime(), 0);
1805  return result;
1806  }
1807  fpreal64 getScaleTolerance() const { return myScaleTolerance; }
1808  void setScaleTolerance(fpreal64 val) { myScaleTolerance = val; }
1810  {
1811  SOP_Node *thissop = cookparms.getNode();
1812  if (!thissop) return getScaleTolerance();
1813  fpreal64 result;
1814  OP_Utils::evalOpParm(result, thissop, "scaletolerance", cookparms.getCookTime(), 0);
1815  return result;
1816  }
1817  int64 getRandSeed() const { return myRandSeed; }
1818  void setRandSeed(int64 val) { myRandSeed = val; }
1819  int64 opRandSeed(const SOP_NodeVerb::CookParms &cookparms) const
1820  {
1821  SOP_Node *thissop = cookparms.getNode();
1822  if (!thissop) return getRandSeed();
1823  int64 result;
1824  OP_Utils::evalOpParm(result, thissop, "randseed", cookparms.getCookTime(), 0);
1825  return result;
1826  }
1827  TargetType getTargetType() const { return TargetType(myTargetType); }
1828  void setTargetType(TargetType val) { myTargetType = int64(val); }
1830  {
1831  SOP_Node *thissop = cookparms.getNode();
1832  if (!thissop) return getTargetType();
1833  int64 result;
1834  OP_Utils::evalOpParm(result, thissop, "targettype", cookparms.getCookTime(), 0);
1835  return TargetType(result);
1836  }
1837  bool getUseDefaultTarget() const { return myUseDefaultTarget; }
1838  void setUseDefaultTarget(bool val) { myUseDefaultTarget = val; }
1839  bool opUseDefaultTarget(const SOP_NodeVerb::CookParms &cookparms) const
1840  {
1841  SOP_Node *thissop = cookparms.getNode();
1842  if (!thissop) return getUseDefaultTarget();
1843  bool result;
1844  OP_Utils::evalOpParm(result, thissop, "usedefaulttarget", cookparms.getCookTime(), 0);
1845  return result;
1846  }
1847  int64 getDefaultTarget() const { return myDefaultTarget; }
1848  void setDefaultTarget(int64 val) { myDefaultTarget = val; }
1850  {
1851  SOP_Node *thissop = cookparms.getNode();
1852  if (!thissop) return getDefaultTarget();
1853  int64 result;
1854  OP_Utils::evalOpParm(result, thissop, "defaulttarget", cookparms.getCookTime(), 0);
1855  return result;
1856  }
1857  bool getUseDefaultUdimTarget() const { return myUseDefaultUdimTarget; }
1858  void setUseDefaultUdimTarget(bool val) { myUseDefaultUdimTarget = val; }
1860  {
1861  SOP_Node *thissop = cookparms.getNode();
1862  if (!thissop) return getUseDefaultUdimTarget();
1863  bool result;
1864  OP_Utils::evalOpParm(result, thissop, "usedefaultudimtarget", cookparms.getCookTime(), 0);
1865  return result;
1866  }
1867  int64 getDefaultUdimTarget() const { return myDefaultUdimTarget; }
1868  void setDefaultUdimTarget(int64 val) { myDefaultUdimTarget = val; }
1870  {
1871  SOP_Node *thissop = cookparms.getNode();
1872  if (!thissop) return getDefaultUdimTarget();
1873  int64 result;
1874  OP_Utils::evalOpParm(result, thissop, "defaultudimtarget", cookparms.getCookTime(), 0);
1875  return result;
1876  }
1877  const UT_Array<Rects> &getRects() const { return myRects; }
1878 void setRects(const UT_Array<Rects> &val) { myRects = val; }
1879  exint opRects(const SOP_NodeVerb::CookParms &cookparms) const
1880  {
1881  SOP_Node *thissop = cookparms.getNode();
1882  if (!thissop) return getRects().entries();
1883  exint result;
1884  OP_Utils::evalOpParm(result, thissop, "rects", cookparms.getCookTime(), 0);
1885  return result;
1886  }
1887  bool opRects_rect_use(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1888  { return opinstRects_rect_use(cookparms, &_idx); }
1889  bool opinstRects_rect_use(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1890  {
1891  SOP_Node *thissop = cookparms.getNode();
1892  if (!thissop) return (myRects(_idx[0]).rect_use);
1893  int _parmidx[2-1];
1894  _parmidx[1-1] = _idx[1-1] + 0;
1895 
1896  bool result;
1897  OP_Utils::evalOpParmInst(result, thissop, "rect_use#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1898  return (result);
1899  }
1900  UT_Vector2D opRects_rect_center(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1901  { return opinstRects_rect_center(cookparms, &_idx); }
1902  UT_Vector2D opinstRects_rect_center(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1903  {
1904  SOP_Node *thissop = cookparms.getNode();
1905  if (!thissop) return (myRects(_idx[0]).rect_center);
1906  int _parmidx[2-1];
1907  _parmidx[1-1] = _idx[1-1] + 0;
1908 
1910  OP_Utils::evalOpParmInst(result, thissop, "rect_center#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1911  return (result);
1912  }
1913  UT_Vector2D opRects_rect_size(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1914  { return opinstRects_rect_size(cookparms, &_idx); }
1915  UT_Vector2D opinstRects_rect_size(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1916  {
1917  SOP_Node *thissop = cookparms.getNode();
1918  if (!thissop) return (myRects(_idx[0]).rect_size);
1919  int _parmidx[2-1];
1920  _parmidx[1-1] = _idx[1-1] + 0;
1921 
1923  OP_Utils::evalOpParmInst(result, thissop, "rect_size#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1924  return (result);
1925  }
1926 
1927  UT_Vector2D getTileSize() const { return myTileSize; }
1928  void setTileSize(UT_Vector2D val) { myTileSize = val; }
1930  {
1931  SOP_Node *thissop = cookparms.getNode();
1932  if (!thissop) return getTileSize();
1934  OP_Utils::evalOpParm(result, thissop, "tilesize", cookparms.getCookTime(), 0);
1935  return result;
1936  }
1937  int64 getNumColumns() const { return myNumColumns; }
1938  void setNumColumns(int64 val) { myNumColumns = val; }
1940  {
1941  SOP_Node *thissop = cookparms.getNode();
1942  if (!thissop) return getNumColumns();
1943  int64 result;
1944  OP_Utils::evalOpParm(result, thissop, "numcolumns", cookparms.getCookTime(), 0);
1945  return result;
1946  }
1947  int64 getStartingUdim() const { return myStartingUdim; }
1948  void setStartingUdim(int64 val) { myStartingUdim = val; }
1950  {
1951  SOP_Node *thissop = cookparms.getNode();
1952  if (!thissop) return getStartingUdim();
1953  int64 result;
1954  OP_Utils::evalOpParm(result, thissop, "startingudim", cookparms.getCookTime(), 0);
1955  return result;
1956  }
1957  const UT_StringHolder & getTargetUVAttr() const { return myTargetUVAttr; }
1958  void setTargetUVAttr(const UT_StringHolder & val) { myTargetUVAttr = val; }
1960  {
1961  SOP_Node *thissop = cookparms.getNode();
1962  if (!thissop) return getTargetUVAttr();
1964  OP_Utils::evalOpParm(result, thissop, "targetuvattrib", cookparms.getCookTime(), 0);
1965  return result;
1966  }
1967  TargetProjPlane getTargetProjPlane() const { return TargetProjPlane(myTargetProjPlane); }
1968  void setTargetProjPlane(TargetProjPlane val) { myTargetProjPlane = int64(val); }
1970  {
1971  SOP_Node *thissop = cookparms.getNode();
1972  if (!thissop) return getTargetProjPlane();
1973  int64 result;
1974  OP_Utils::evalOpParm(result, thissop, "targetprojplane", cookparms.getCookTime(), 0);
1975  return TargetProjPlane(result);
1976  }
1977  const UT_StringHolder & getTargetGroup() const { return myTargetGroup; }
1978  void setTargetGroup(const UT_StringHolder & val) { myTargetGroup = val; }
1980  {
1981  SOP_Node *thissop = cookparms.getNode();
1982  if (!thissop) return getTargetGroup();
1984  OP_Utils::evalOpParm(result, thissop, "targetgroup", cookparms.getCookTime(), 0);
1985  return result;
1986  }
1987  const UT_StringHolder & getTargetSeparatorEdges() const { return myTargetSeparatorEdges; }
1988  void setTargetSeparatorEdges(const UT_StringHolder & val) { myTargetSeparatorEdges = val; }
1990  {
1991  SOP_Node *thissop = cookparms.getNode();
1992  if (!thissop) return getTargetSeparatorEdges();
1994  OP_Utils::evalOpParm(result, thissop, "targetseparatoredges", cookparms.getCookTime(), 0);
1995  return result;
1996  }
1997  bool getUseTargetIslandAttr() const { return myUseTargetIslandAttr; }
1998  void setUseTargetIslandAttr(bool val) { myUseTargetIslandAttr = val; }
1999  bool opUseTargetIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
2000  {
2001  SOP_Node *thissop = cookparms.getNode();
2002  if (!thissop) return getUseTargetIslandAttr();
2003  bool result;
2004  OP_Utils::evalOpParm(result, thissop, "usetargetislandattr", cookparms.getCookTime(), 0);
2005  return result;
2006  }
2007  const UT_StringHolder & getTargetIslandAttr() const { return myTargetIslandAttr; }
2008  void setTargetIslandAttr(const UT_StringHolder & val) { myTargetIslandAttr = val; }
2010  {
2011  SOP_Node *thissop = cookparms.getNode();
2012  if (!thissop) return getTargetIslandAttr();
2014  OP_Utils::evalOpParm(result, thissop, "targetislandattr", cookparms.getCookTime(), 0);
2015  return result;
2016  }
2017  bool getStackIslands() const { return myStackIslands; }
2018  void setStackIslands(bool val) { myStackIslands = val; }
2019  bool opStackIslands(const SOP_NodeVerb::CookParms &cookparms) const
2020  {
2021  SOP_Node *thissop = cookparms.getNode();
2022  if (!thissop) return getStackIslands();
2023  bool result;
2024  OP_Utils::evalOpParm(result, thissop, "stackislands", cookparms.getCookTime(), 0);
2025  return result;
2026  }
2027  bool getStackMirrored() const { return myStackMirrored; }
2028  void setStackMirrored(bool val) { myStackMirrored = val; }
2029  bool opStackMirrored(const SOP_NodeVerb::CookParms &cookparms) const
2030  {
2031  SOP_Node *thissop = cookparms.getNode();
2032  if (!thissop) return getStackMirrored();
2033  bool result;
2034  OP_Utils::evalOpParm(result, thissop, "invertedoverlays", cookparms.getCookTime(), 0);
2035  return result;
2036  }
2037  bool getStackOnNonGroup() const { return myStackOnNonGroup; }
2038  void setStackOnNonGroup(bool val) { myStackOnNonGroup = val; }
2039  bool opStackOnNonGroup(const SOP_NodeVerb::CookParms &cookparms) const
2040  {
2041  SOP_Node *thissop = cookparms.getNode();
2042  if (!thissop) return getStackOnNonGroup();
2043  bool result;
2044  OP_Utils::evalOpParm(result, thissop, "stackonnongroup", cookparms.getCookTime(), 0);
2045  return result;
2046  }
2047  fpreal64 getStackingLengthTolerance() const { return myStackingLengthTolerance; }
2048  void setStackingLengthTolerance(fpreal64 val) { myStackingLengthTolerance = val; }
2050  {
2051  SOP_Node *thissop = cookparms.getNode();
2052  if (!thissop) return getStackingLengthTolerance();
2053  fpreal64 result;
2054  OP_Utils::evalOpParm(result, thissop, "overlaytolerance", cookparms.getCookTime(), 0);
2055  return result;
2056  }
2057  bool getGenerateNonpackedPolys() const { return myGenerateNonpackedPolys; }
2058  void setGenerateNonpackedPolys(bool val) { myGenerateNonpackedPolys = val; }
2060  {
2061  SOP_Node *thissop = cookparms.getNode();
2062  if (!thissop) return getGenerateNonpackedPolys();
2063  bool result;
2064  OP_Utils::evalOpParm(result, thissop, "generatenonpackedpoly", cookparms.getCookTime(), 0);
2065  return result;
2066  }
2067  const UT_StringHolder & getNonpackedPolys() const { return myNonpackedPolys; }
2068  void setNonpackedPolys(const UT_StringHolder & val) { myNonpackedPolys = val; }
2070  {
2071  SOP_Node *thissop = cookparms.getNode();
2072  if (!thissop) return getNonpackedPolys();
2074  OP_Utils::evalOpParm(result, thissop, "nonpackedpolys", cookparms.getCookTime(), 0);
2075  return result;
2076  }
2077  bool getGenerateIslandAttr() const { return myGenerateIslandAttr; }
2078  void setGenerateIslandAttr(bool val) { myGenerateIslandAttr = val; }
2079  bool opGenerateIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
2080  {
2081  SOP_Node *thissop = cookparms.getNode();
2082  if (!thissop) return getGenerateIslandAttr();
2083  bool result;
2084  OP_Utils::evalOpParm(result, thissop, "generateislandattr", cookparms.getCookTime(), 0);
2085  return result;
2086  }
2087  const UT_StringHolder & getOutputIslandAttr() const { return myOutputIslandAttr; }
2088  void setOutputIslandAttr(const UT_StringHolder & val) { myOutputIslandAttr = val; }
2090  {
2091  SOP_Node *thissop = cookparms.getNode();
2092  if (!thissop) return getOutputIslandAttr();
2094  OP_Utils::evalOpParm(result, thissop, "outputislandattr", cookparms.getCookTime(), 0);
2095  return result;
2096  }
2097  bool getGenerateTargetAttr() const { return myGenerateTargetAttr; }
2098  void setGenerateTargetAttr(bool val) { myGenerateTargetAttr = val; }
2099  bool opGenerateTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
2100  {
2101  SOP_Node *thissop = cookparms.getNode();
2102  if (!thissop) return getGenerateTargetAttr();
2103  bool result;
2104  OP_Utils::evalOpParm(result, thissop, "generatetargetattr", cookparms.getCookTime(), 0);
2105  return result;
2106  }
2107  const UT_StringHolder & getOutputTargetAttr() const { return myOutputTargetAttr; }
2108  void setOutputTargetAttr(const UT_StringHolder & val) { myOutputTargetAttr = val; }
2110  {
2111  SOP_Node *thissop = cookparms.getNode();
2112  if (!thissop) return getOutputTargetAttr();
2114  OP_Utils::evalOpParm(result, thissop, "outputtargetattr", cookparms.getCookTime(), 0);
2115  return result;
2116  }
2117 
2118 private:
2119  UT_StringHolder myUVAttr;
2120  int64 myUVProjPlane;
2121  UT_StringHolder myGroup;
2122  UT_StringHolder mySeparatorEdges;
2123  bool myUseIslandAttr;
2124  UT_StringHolder myIslandAttr;
2125  bool myUseTargetAttr;
2126  UT_StringHolder myTargetAttr;
2127  UT_StringHolder myTargetOverrides;
2128  bool myUseIslandScaleAttr;
2129  UT_StringHolder myIslandScaleAttr;
2130  UT_StringHolder myScaleOverrides;
2131  bool myUseIslandOffsetAttr;
2132  UT_StringHolder myIslandOffsetAttr;
2133  UT_StringHolder myOffsetOverrides;
2134  bool myCorrectAreas;
2135  int64 myAxisAlignment;
2136  int64 myScaling;
2137  fpreal64 myScale;
2138  int64 myRotationStep;
2139  int64 myCircleDivs;
2140  bool myPackBetween;
2141  bool myPackInCavities;
2142  int64 myPadding;
2143  bool myPadBoundaries;
2144  bool myExpandPadding;
2145  int64 myIterations;
2146  int64 myResolution;
2147  int64 myCustomResolution;
2148  fpreal64 myConnectivityTolerance;
2149  fpreal64 myScaleTolerance;
2150  int64 myRandSeed;
2151  int64 myTargetType;
2152  bool myUseDefaultTarget;
2153  int64 myDefaultTarget;
2154  bool myUseDefaultUdimTarget;
2155  int64 myDefaultUdimTarget;
2156  UT_Array<Rects> myRects;
2157  UT_Vector2D myTileSize;
2158  int64 myNumColumns;
2159  int64 myStartingUdim;
2160  UT_StringHolder myTargetUVAttr;
2161  int64 myTargetProjPlane;
2162  UT_StringHolder myTargetGroup;
2163  UT_StringHolder myTargetSeparatorEdges;
2164  bool myUseTargetIslandAttr;
2165  UT_StringHolder myTargetIslandAttr;
2166  bool myStackIslands;
2167  bool myStackMirrored;
2168  bool myStackOnNonGroup;
2169  fpreal64 myStackingLengthTolerance;
2170  bool myGenerateNonpackedPolys;
2171  UT_StringHolder myNonpackedPolys;
2172  bool myGenerateIslandAttr;
2173  UT_StringHolder myOutputIslandAttr;
2174  bool myGenerateTargetAttr;
2175  UT_StringHolder myOutputTargetAttr;
2176 
2177 };
type
Definition: core.h:977
void setIslandScaleAttr(const UT_StringHolder &val)
bool opRects_rect_use(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
TargetType getTargetType() const
void loadFromOpSubclass(const LoadParms &loadparms) override
UT_Vector2D opRects_rect_size(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
void setUVProjPlane(UVProjPlane val)
void setStackingLengthTolerance(fpreal64 val)
bool opGenerateTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
void setTargetAttr(const UT_StringHolder &val)
exint nodeIdx() const
Definition: SOP_NodeVerb.h:102
const UT_StringHolder & getTargetUVAttr() const
int int32
Definition: SYS_Types.h:39
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:734
const UT_StringHolder & getTargetIslandAttr() const
void setTargetType(TargetType val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
UT_StringHolder opScaleOverrides(const SOP_NodeVerb::CookParms &cookparms) const
virtual NodeIdx getInput(NodeIdx idx, int input, bool markused=false) const =0
void
Definition: png.h:1083
UT_Vector2D opinstRects_rect_size(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
fpreal getTime() const
Definition: OP_Context.h:60
const UT_StringHolder & getUVAttr() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
UT_Vector2T< fpreal64 > UT_Vector2D
static void saveData(std::ostream &os, fpreal64 v)
const UT_StringHolder & getIslandScaleAttr() const
bool operator!=(const Rects &src) const
void setTargetOverrides(const UT_StringHolder &val)
bool opStackOnNonGroup(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargetSeparatorEdges(const SOP_NodeVerb::CookParms &cookparms) const
GLuint GLsizei const GLuint const GLintptr * offsets
Definition: glcorearb.h:2620
bool operator!=(const SOP_UVLayout_3_0Parms &src) const
const GLfloat * c
Definition: glew.h:16631
void setOutputIslandAttr(const UT_StringHolder &val)
bool opUseIslandOffsetAttr(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
bool opPadBoundaries(const SOP_NodeVerb::CookParms &cookparms) const
int64 exint
Definition: SYS_Types.h:125
void setRotationStep(RotationStep val)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
fpreal64 opConnectivityTolerance(const SOP_NodeVerb::CookParms &cookparms) const
const UT_Array< Rects > & getRects() const
bool opCorrectAreas(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_StringHolder s)
SYS_FORCE_INLINE const char * buffer() const
fpreal64 getStackingLengthTolerance() const
const SOP_GraphProxy * graph() const
Definition: SOP_NodeVerb.h:101
RotationStep getRotationStep() const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
An output stream object that owns its own string buffer storage.
static void loadData(UT_IStream &is, int64 &v)
UT_Vector2D opinstRects_rect_center(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
UT_Vector2D getTileSize() const
const char * getNestParmName(TempIndex fieldnum) const override
static void loadData(UT_IStream &is, UT_Vector2I &v)
GLenum src
Definition: glcorearb.h:1792
UVProjPlane opUVProjPlane(const SOP_NodeVerb::CookParms &cookparms) const
int64 opDefaultUdimTarget(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargetIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
bool opStackMirrored(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_StringHolder & getTargetSeparatorEdges() const
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
bool opUseDefaultUdimTarget(const SOP_NodeVerb::CookParms &cookparms) const
int64 opIterations(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
const UT_StringHolder & getSeparatorEdges() const
bool opinstRects_rect_use(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
void setGenerateNonpackedPolys(bool val)
bool opStackIslands(const SOP_NodeVerb::CookParms &cookparms) const
void setDefaultUdimTarget(int64 val)
static void loadData(UT_IStream &is, UT_Vector3I &v)
RotationStep opRotationStep(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
double fpreal64
Definition: SYS_Types.h:201
bool opUseTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
static void loadData(UT_IStream &is, fpreal64 &v)
int64 opNumColumns(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getTargetGroup() const
int64 opPadding(const SOP_NodeVerb::CookParms &cookparms) const
void setConnectivityTolerance(fpreal64 val)
UT_StringHolder opSeparatorEdges(const SOP_NodeVerb::CookParms &cookparms) const
GLuint64EXT * result
Definition: glew.h:14311
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
void setResolution(Resolution val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
SYS_FORCE_INLINE T & y()
Definition: UT_Vector3.h:508
static void loadData(UT_IStream &is, UT_Vector4D &v)
void setScaleTolerance(fpreal64 val)
exint length() const
bool opExpandPadding(const SOP_NodeVerb::CookParms &cookparms) const
AxisAlignment opAxisAlignment(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
UT_StringHolder opTargetUVAttr(const SOP_NodeVerb::CookParms &cookparms) const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:30
bool opPackInCavities(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, bool &v)
static void saveData(std::ostream &os, bool v)
fpreal64 opScale(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2D opTileSize(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector2D v)
UT_Vector2D opRects_rect_center(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
const GLdouble * v
Definition: glcorearb.h:836
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:288
UT_StringHolder opIslandScaleAttr(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & z()
Definition: UT_Vector3.h:510
exint getNestNumParms(TempIndex idx) const override
UT_StringHolder opNonpackedPolys(const SOP_NodeVerb::CookParms &cookparms) const
bool opGenerateNonpackedPolys(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
void setIslandAttr(const UT_StringHolder &val)
long long int64
Definition: SYS_Types.h:116
UT_StringHolder opIslandOffsetAttr(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
const UT_StringHolder & getOutputTargetAttr() const
void setGroup(const UT_StringHolder &val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
TargetType opTargetType(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
UT_StringHolder opIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
UVProjPlane getUVProjPlane() const
Resolution getResolution() const
bool opUseTargetIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getOffsetOverrides() const
UT_StringHolder opOutputIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
TargetProjPlane getTargetProjPlane() const
void copyFrom(const SOP_NodeParms *src) override
static void saveData(std::ostream &os, UT_Vector3D v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
static void saveData(std::ostream &os, UT_Vector4D v)
SYS_FORCE_INLINE void strcat(const char *src)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:287
const UT_StringHolder & getGroup() const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void setTargetUVAttr(const UT_StringHolder &val)
bool operator==(const Rects &src) const
void save(std::ostream &os) const
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:109
void setTileSize(UT_Vector2D val)
bool opPackBetween(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseDefaultTarget(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargetGroup(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix3D v)
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glcorearb.h:2539
int64 opRandSeed(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
exint entries() const
Alias of size(). size() is preferred.
Definition: UT_Array.h:481
GLboolean * data
Definition: glcorearb.h:130
static void loadData(UT_IStream &is, UT_Matrix4D &v)
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794
bool opUseIslandScaleAttr(const SOP_NodeVerb::CookParms &cookparms) const
GLuint GLfloat * val
Definition: glcorearb.h:1607
fpreal64 opScaleTolerance(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setOutputTargetAttr(const UT_StringHolder &val)
int int appendSprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
exint opRects(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargetOverrides(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getIslandOffsetAttr() const
const UT_StringHolder & getOutputIslandAttr() const
const UT_StringHolder & getNonpackedPolys() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
UT_StringHolder opOffsetOverrides(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix2D v)
UT_StringHolder opOutputTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 fpreal
Definition: SYS_Types.h:277
void setRects(const UT_Array< Rects > &val)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
void setNonpackedPolys(const UT_StringHolder &val)
int64 opStartingUdim(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3D &v)
SYS_FORCE_INLINE void append(char character)
Vec3< typename MatType::value_type > getScale(const MatType &mat)
Return a Vec3 representing the lengths of the passed matrix's upper 3×3's rows.
Definition: Mat.h:655
#define SOP_API
Definition: SOP_API.h:10
void setScaleOverrides(const UT_StringHolder &val)
fpreal64 getConnectivityTolerance() const
static void loadData(UT_IStream &is, UT_StringHolder &v)
GLsizei const GLfloat * value
Definition: glcorearb.h:823
const UT_StringHolder & getTargetOverrides() const
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
SYS_FORCE_INLINE T & x()
Definition: UT_Vector3.h:506
void setTargetSeparatorEdges(const UT_StringHolder &val)
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:748
fpreal64 opStackingLengthTolerance(const SOP_NodeVerb::CookParms &cookparms) const
ParmType getNestParmType(TempIndex fieldnum) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
void setSeparatorEdges(const UT_StringHolder &val)
const UT_StringHolder & getIslandAttr() const
AxisAlignment getAxisAlignment() const
static void saveData(std::ostream &os, UT_Matrix4D v)
UT_StringHolder opUVAttr(const SOP_NodeVerb::CookParms &cookparms) const
const char * findChar(int c) const
Definition: UT_String.h:1371
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:171
void setTargetProjPlane(TargetProjPlane val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
Resolution opResolution(const SOP_NodeVerb::CookParms &cookparms) const
void setIslandOffsetAttr(const UT_StringHolder &val)
bool opUseIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
bool opGenerateIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
void setOffsetOverrides(const UT_StringHolder &val)
void setUVAttr(const UT_StringHolder &val)
static void saveData(std::ostream &os, int64 v)
Scaling opScaling(const SOP_NodeVerb::CookParms &cookparms) const
int64 opDefaultTarget(const SOP_NodeVerb::CookParms &cookparms) const
GLboolean r
Definition: glcorearb.h:1221
static void loadData(UT_IStream &is, UT_Vector4I &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
UT_StringHolder opTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
TargetProjPlane opTargetProjPlane(const SOP_NodeVerb::CookParms &cookparms) const
GLdouble s
Definition: glew.h:1395
void setTargetIslandAttr(const UT_StringHolder &val)
const UT_StringHolder & getTargetAttr() const
void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:107
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:89
void setAxisAlignment(AxisAlignment val)
int64 opCustomResolution(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getScaleTolerance() const
SYS_FORCE_INLINE bool isstring() const
int64 opCircleDivs(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getScaleOverrides() const
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
UT_StringHolder createString(const UT_Array< Rects > &list) const
virtual void evalOpParmInst(int64 &v, NodeIdx node, const char *parmname, const int *inst, const int *offsets, fpreal time, DEP_MicroNode *depnode, int nestlevel=1) const =0
bool operator==(const SOP_UVLayout_3_0Parms &src) const
void setUseDefaultUdimTarget(bool val)
void setTargetGroup(const UT_StringHolder &val)