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