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