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