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