20 using namespace UT::Literal;
23 namespace SOP_UVLayout_3_0Enums
98 if (rect_use != src.
rect_use)
return false;
100 if (rect_size != src.
rect_size)
return false;
116 for (
int i = 0; i < list.
entries(); i++)
122 buf.
appendSprintf(
"%s", (list(i).rect_use) ?
"true" :
"false");
124 buf.
appendSprintf(
"(%f, %f)", list(i).rect_center.x(), list(i).rect_center.y());
126 buf.
appendSprintf(
"(%f, %f)", list(i).rect_size.x(), list(i).rect_size.y());
141 mySeparatorEdges =
""_sh;
142 myUseIslandAttr =
false;
143 myIslandAttr =
"island"_sh;
144 myUseTargetAttr =
false;
145 myTargetAttr =
"udim"_sh;
146 myTargetOverrides =
""_sh;
147 myUseIslandScaleAttr =
false;
148 myIslandScaleAttr =
"iscale"_sh;
149 myScaleOverrides =
""_sh;
150 myUseIslandOffsetAttr =
false;
151 myIslandOffsetAttr =
"ioffset"_sh;
152 myOffsetOverrides =
""_sh;
153 myCorrectAreas =
false;
159 myPackBetween =
false;
160 myPackInCavities =
true;
162 myPadBoundaries =
false;
163 myExpandPadding =
false;
166 myCustomResolution = 1024;
167 myConnectivityTolerance = 1e-05;
168 myScaleTolerance = 0.005;
171 myUseDefaultTarget =
false;
173 myUseDefaultUdimTarget =
false;
174 myDefaultUdimTarget = 1001;
177 myStartingUdim = 1001;
178 myTargetUVAttr =
"uv"_sh;
179 myTargetProjPlane = 0;
180 myTargetGroup =
""_sh;
181 myTargetSeparatorEdges =
""_sh;
182 myUseTargetIslandAttr =
false;
183 myTargetIslandAttr =
"targetisland"_sh;
184 myStackIslands =
false;
185 myStackMirrored =
false;
186 myStackOnNonGroup =
false;
187 myStackingLengthTolerance = 0.02;
188 myGenerateNonpackedPolys =
false;
189 myNonpackedPolys =
"nonpacked"_sh;
190 myGenerateIslandAttr =
false;
191 myOutputIslandAttr =
"island"_sh;
192 myGenerateTargetAttr =
false;
193 myOutputTargetAttr =
"target"_sh;
203 if (myUVAttr != src.myUVAttr)
return false;
204 if (myUVProjPlane != src.myUVProjPlane)
return false;
205 if (myGroup != src.myGroup)
return false;
206 if (mySeparatorEdges != src.mySeparatorEdges)
return false;
207 if (myUseIslandAttr != src.myUseIslandAttr)
return false;
208 if (myIslandAttr != src.myIslandAttr)
return false;
209 if (myUseTargetAttr != src.myUseTargetAttr)
return false;
210 if (myTargetAttr != src.myTargetAttr)
return false;
211 if (myTargetOverrides != src.myTargetOverrides)
return false;
212 if (myUseIslandScaleAttr != src.myUseIslandScaleAttr)
return false;
213 if (myIslandScaleAttr != src.myIslandScaleAttr)
return false;
214 if (myScaleOverrides != src.myScaleOverrides)
return false;
215 if (myUseIslandOffsetAttr != src.myUseIslandOffsetAttr)
return false;
216 if (myIslandOffsetAttr != src.myIslandOffsetAttr)
return false;
217 if (myOffsetOverrides != src.myOffsetOverrides)
return false;
218 if (myCorrectAreas != src.myCorrectAreas)
return false;
219 if (myAxisAlignment != src.myAxisAlignment)
return false;
220 if (myScaling != src.myScaling)
return false;
221 if (myScale != src.myScale)
return false;
222 if (myRotationStep != src.myRotationStep)
return false;
223 if (myCircleDivs != src.myCircleDivs)
return false;
224 if (myPackBetween != src.myPackBetween)
return false;
225 if (myPackInCavities != src.myPackInCavities)
return false;
226 if (myPadding != src.myPadding)
return false;
227 if (myPadBoundaries != src.myPadBoundaries)
return false;
228 if (myExpandPadding != src.myExpandPadding)
return false;
229 if (myIterations != src.myIterations)
return false;
230 if (myResolution != src.myResolution)
return false;
231 if (myCustomResolution != src.myCustomResolution)
return false;
232 if (myConnectivityTolerance != src.myConnectivityTolerance)
return false;
233 if (myScaleTolerance != src.myScaleTolerance)
return false;
234 if (myRandSeed != src.myRandSeed)
return false;
235 if (myTargetType != src.myTargetType)
return false;
236 if (myUseDefaultTarget != src.myUseDefaultTarget)
return false;
237 if (myDefaultTarget != src.myDefaultTarget)
return false;
238 if (myUseDefaultUdimTarget != src.myUseDefaultUdimTarget)
return false;
239 if (myDefaultUdimTarget != src.myDefaultUdimTarget)
return false;
240 if (myRects != src.myRects)
return false;
241 if (myTileSize != src.myTileSize)
return false;
242 if (myNumColumns != src.myNumColumns)
return false;
243 if (myStartingUdim != src.myStartingUdim)
return false;
244 if (myTargetUVAttr != src.myTargetUVAttr)
return false;
245 if (myTargetProjPlane != src.myTargetProjPlane)
return false;
246 if (myTargetGroup != src.myTargetGroup)
return false;
247 if (myTargetSeparatorEdges != src.myTargetSeparatorEdges)
return false;
248 if (myUseTargetIslandAttr != src.myUseTargetIslandAttr)
return false;
249 if (myTargetIslandAttr != src.myTargetIslandAttr)
return false;
250 if (myStackIslands != src.myStackIslands)
return false;
251 if (myStackMirrored != src.myStackMirrored)
return false;
252 if (myStackOnNonGroup != src.myStackOnNonGroup)
return false;
253 if (myStackingLengthTolerance != src.myStackingLengthTolerance)
return false;
254 if (myGenerateNonpackedPolys != src.myGenerateNonpackedPolys)
return false;
255 if (myNonpackedPolys != src.myNonpackedPolys)
return false;
256 if (myGenerateIslandAttr != src.myGenerateIslandAttr)
return false;
257 if (myOutputIslandAttr != src.myOutputIslandAttr)
return false;
258 if (myGenerateTargetAttr != src.myGenerateTargetAttr)
return false;
259 if (myOutputTargetAttr != src.myOutputTargetAttr)
return false;
281 graph->
evalOpParm(myUVAttr, nodeidx,
"uvattrib", time, 0);
284 graph->
evalOpParm(myUVProjPlane, nodeidx,
"projplane", time, 0);
287 graph->
evalOpParm(myGroup, nodeidx,
"group", time, 0);
288 mySeparatorEdges =
""_sh;
290 graph->
evalOpParm(mySeparatorEdges, nodeidx,
"separatoredges", time, 0);
291 myUseIslandAttr =
false;
293 graph->
evalOpParm(myUseIslandAttr, nodeidx,
"useislandattr", time, 0);
294 myIslandAttr =
"island"_sh;
295 if (
true && ( (!(((getUseIslandAttr()==0)))) ) )
296 graph->
evalOpParm(myIslandAttr, nodeidx,
"islandattr", time, 0);
297 myUseTargetAttr =
false;
299 graph->
evalOpParm(myUseTargetAttr, nodeidx,
"usetargetattr", time, 0);
300 myTargetAttr =
"udim"_sh;
301 if (
true && ( (!(((getUseTargetAttr()==0)))) ) )
302 graph->
evalOpParm(myTargetAttr, nodeidx,
"targetattr", time, 0);
303 myTargetOverrides =
""_sh;
305 graph->
evalOpParm(myTargetOverrides, nodeidx,
"targetoverrides", time, 0);
306 myUseIslandScaleAttr =
false;
308 graph->
evalOpParm(myUseIslandScaleAttr, nodeidx,
"useislandscaleattr", time, 0);
309 myIslandScaleAttr =
"iscale"_sh;
310 if (
true && ( (!(((getUseIslandScaleAttr()==0)))) ) )
311 graph->
evalOpParm(myIslandScaleAttr, nodeidx,
"islandscaleattr", time, 0);
312 myScaleOverrides =
""_sh;
314 graph->
evalOpParm(myScaleOverrides, nodeidx,
"scaleoverrides", time, 0);
315 myUseIslandOffsetAttr =
false;
317 graph->
evalOpParm(myUseIslandOffsetAttr, nodeidx,
"useislandsetattr", time, 0);
318 myIslandOffsetAttr =
"ioffset"_sh;
319 if (
true && ( (!(((getUseIslandOffsetAttr()==0)))) ) )
320 graph->
evalOpParm(myIslandOffsetAttr, nodeidx,
"islandoffsetattr", time, 0);
321 myOffsetOverrides =
""_sh;
323 graph->
evalOpParm(myOffsetOverrides, nodeidx,
"offsetoverrides", time, 0);
324 myCorrectAreas =
false;
326 graph->
evalOpParm(myCorrectAreas, nodeidx,
"correctareas", time, 0);
329 graph->
evalOpParm(myAxisAlignment, nodeidx,
"axisalignislands", time, 0);
332 graph->
evalOpParm(myScaling, nodeidx,
"scaling", time, 0);
334 if (
true && ( (!(((
int64(getScaling())!=1)))) ) )
335 graph->
evalOpParm(myScale, nodeidx,
"scale", time, 0);
338 graph->
evalOpParm(myRotationStep, nodeidx,
"rotstep", time, 0);
340 if (
true && ( (!(((
int64(getRotationStep())!=7)))) ) )
341 graph->
evalOpParm(myCircleDivs, nodeidx,
"circledivs", time, 0);
342 myPackBetween =
false;
344 graph->
evalOpParm(myPackBetween, nodeidx,
"packbetween", time, 0);
345 myPackInCavities =
true;
347 graph->
evalOpParm(myPackInCavities, nodeidx,
"packincavities", time, 0);
350 graph->
evalOpParm(myPadding, nodeidx,
"padding", time, 0);
351 myPadBoundaries =
false;
353 graph->
evalOpParm(myPadBoundaries, nodeidx,
"paddingboundary", time, 0);
354 myExpandPadding =
false;
356 graph->
evalOpParm(myExpandPadding, nodeidx,
"expandpadding", time, 0);
359 graph->
evalOpParm(myIterations, nodeidx,
"iterations", time, 0);
362 graph->
evalOpParm(myResolution, nodeidx,
"resolution", time, 0);
363 myCustomResolution = 1024;
364 if (
true && ( (!(((
int64(getResolution())!=5)))) ) )
365 graph->
evalOpParm(myCustomResolution, nodeidx,
"customresolution", time, 0);
366 myConnectivityTolerance = 1e-05;
368 graph->
evalOpParm(myConnectivityTolerance, nodeidx,
"uvtolerance", time, 0);
369 myScaleTolerance = 0.005;
370 if (
true && ( (!(((
int64(getScaling())==1)))) ) )
371 graph->
evalOpParm(myScaleTolerance, nodeidx,
"scaletolerance", time, 0);
373 if (
true && ( (!(((
int64(getIterations())==1)))) ) )
374 graph->
evalOpParm(myRandSeed, nodeidx,
"randseed", time, 0);
377 graph->
evalOpParm(myTargetType, nodeidx,
"targettype", time, 0);
378 myUseDefaultTarget =
false;
379 if (
true && ( (!(((
int64(getTargetType())==1)))) ) )
380 graph->
evalOpParm(myUseDefaultTarget, nodeidx,
"usedefaulttarget", time, 0);
382 if (
true && ( (!(((getUseDefaultTarget()==0))||((
int64(getTargetType())==1)))) ) )
383 graph->
evalOpParm(myDefaultTarget, nodeidx,
"defaulttarget", time, 0);
384 myUseDefaultUdimTarget =
false;
385 if (
true && ( (!(((
int64(getTargetType())!=1)))) ) )
386 graph->
evalOpParm(myUseDefaultUdimTarget, nodeidx,
"usedefaultudimtarget", time, 0);
387 myDefaultUdimTarget = 1001;
388 if (
true && ( (!(((getUseDefaultUdimTarget()==0))||((
int64(getTargetType())!=1)))) ) )
389 graph->
evalOpParm(myDefaultUdimTarget, nodeidx,
"defaultudimtarget", time, 0);
390 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) )
393 graph->
evalOpParm(length, nodeidx,
"rects", time, 0);
394 myRects.entries(length);
398 auto && _curentry = myRects(i);
400 myRects(i).rect_use =
true;
401 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) && ( (!(((
int64(getTargetType())!=0)))) ) )
402 graph->
evalOpParmInst(myRects(i).rect_use, nodeidx,
"rect_use#", &parmidx, time, 0);
404 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) && ( (!(((
int64(getTargetType())!=0))||((_curentry.rect_use==0)))) ) )
405 graph->
evalOpParmInst(myRects(i).rect_center, nodeidx,
"rect_center#", &parmidx, time, 0);
407 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) && ( (!(((
int64(getTargetType())!=0))||((_curentry.rect_use==0)))) ) )
408 graph->
evalOpParmInst(myRects(i).rect_size, nodeidx,
"rect_size#", &parmidx, time, 0);
415 if (
true && ( (!(((
int64(getTargetType())!=1)))) ) )
416 graph->
evalOpParm(myTileSize, nodeidx,
"tilesize", time, 0);
418 if (
true && ( (!(((
int64(getTargetType())!=1)))) ) )
419 graph->
evalOpParm(myNumColumns, nodeidx,
"numcolumns", time, 0);
420 myStartingUdim = 1001;
421 if (
true && ( (!(((
int64(getTargetType())!=1)))) ) )
422 graph->
evalOpParm(myStartingUdim, nodeidx,
"startingudim", time, 0);
423 myTargetUVAttr =
"uv"_sh;
424 if (
true && ( (!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
425 graph->
evalOpParm(myTargetUVAttr, nodeidx,
"targetuvattrib", time, 0);
426 myTargetProjPlane = 0;
427 if (
true && ( (!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
428 graph->
evalOpParm(myTargetProjPlane, nodeidx,
"targetprojplane", time, 0);
429 myTargetGroup =
""_sh;
430 if (
true && ( (!((((graph->
getInput(nodeidx,1)>=0)==0))||((
int64(getTargetType())!=2)))) ) )
431 graph->
evalOpParm(myTargetGroup, nodeidx,
"targetgroup", time, 0);
432 myTargetSeparatorEdges =
""_sh;
433 if (
true && ( (!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0))||((
int64(getTargetType())!=2)))) ) )
434 graph->
evalOpParm(myTargetSeparatorEdges, nodeidx,
"targetseparatoredges", time, 0);
435 myUseTargetIslandAttr =
false;
436 if (
true && ( (!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0))||((
int64(getTargetType())!=2)))) ) )
437 graph->
evalOpParm(myUseTargetIslandAttr, nodeidx,
"usetargetislandattr", time, 0);
438 myTargetIslandAttr =
"targetisland"_sh;
439 if (
true && ( (!(((
int64(getTargetType())!=2))||((getUseTargetIslandAttr()==0))||((
int64(getTargetType())!=2)))) ) )
440 graph->
evalOpParm(myTargetIslandAttr, nodeidx,
"targetislandattr", time, 0);
441 myStackIslands =
false;
443 graph->
evalOpParm(myStackIslands, nodeidx,
"stackislands", time, 0);
444 myStackMirrored =
false;
445 if (
true && ( (!(((getStackIslands()==0)))) ) )
446 graph->
evalOpParm(myStackMirrored, nodeidx,
"invertedoverlays", time, 0);
447 myStackOnNonGroup =
false;
448 if (
true && ( (!(((getStackIslands()==0)))) ) )
449 graph->
evalOpParm(myStackOnNonGroup, nodeidx,
"stackonnongroup", time, 0);
450 myStackingLengthTolerance = 0.02;
451 if (
true && ( (!(((getStackIslands()==0)))) ) )
452 graph->
evalOpParm(myStackingLengthTolerance, nodeidx,
"overlaytolerance", time, 0);
453 myGenerateNonpackedPolys =
false;
455 graph->
evalOpParm(myGenerateNonpackedPolys, nodeidx,
"generatenonpackedpoly", time, 0);
456 myNonpackedPolys =
"nonpacked"_sh;
457 if (
true && ( (!(((getGenerateNonpackedPolys()==0)))) ) )
458 graph->
evalOpParm(myNonpackedPolys, nodeidx,
"nonpackedpolys", time, 0);
459 myGenerateIslandAttr =
false;
461 graph->
evalOpParm(myGenerateIslandAttr, nodeidx,
"generateislandattr", time, 0);
462 myOutputIslandAttr =
"island"_sh;
463 if (
true && ( (!(((getGenerateIslandAttr()==0)))) ) )
464 graph->
evalOpParm(myOutputIslandAttr, nodeidx,
"outputislandattr", time, 0);
465 myGenerateTargetAttr =
false;
467 graph->
evalOpParm(myGenerateTargetAttr, nodeidx,
"generatetargetattr", time, 0);
468 myOutputTargetAttr =
"target"_sh;
469 if (
true && ( (!(((getGenerateTargetAttr()==0)))) ) )
470 graph->
evalOpParm(myOutputTargetAttr, nodeidx,
"outputtargetattr", time, 0);
486 template <
typename T>
493 if (idx.
size() != instance.
size()+1)
498 coerceValue(value, myUVAttr);
501 coerceValue(value, myUVProjPlane);
504 coerceValue(value, myGroup);
507 coerceValue(value, mySeparatorEdges);
510 coerceValue(value, myUseIslandAttr);
513 coerceValue(value, myIslandAttr);
516 coerceValue(value, myUseTargetAttr);
519 coerceValue(value, myTargetAttr);
522 coerceValue(value, myTargetOverrides);
525 coerceValue(value, myUseIslandScaleAttr);
528 coerceValue(value, myIslandScaleAttr);
531 coerceValue(value, myScaleOverrides);
534 coerceValue(value, myUseIslandOffsetAttr);
537 coerceValue(value, myIslandOffsetAttr);
540 coerceValue(value, myOffsetOverrides);
543 coerceValue(value, myCorrectAreas);
546 coerceValue(value, myAxisAlignment);
549 coerceValue(value, myScaling);
552 coerceValue(value, myScale);
555 coerceValue(value, myRotationStep);
558 coerceValue(value, myCircleDivs);
561 coerceValue(value, myPackBetween);
564 coerceValue(value, myPackInCavities);
567 coerceValue(value, myPadding);
570 coerceValue(value, myPadBoundaries);
573 coerceValue(value, myExpandPadding);
576 coerceValue(value, myIterations);
579 coerceValue(value, myResolution);
582 coerceValue(value, myCustomResolution);
585 coerceValue(value, myConnectivityTolerance);
588 coerceValue(value, myScaleTolerance);
591 coerceValue(value, myRandSeed);
594 coerceValue(value, myTargetType);
597 coerceValue(value, myUseDefaultTarget);
600 coerceValue(value, myDefaultTarget);
603 coerceValue(value, myUseDefaultUdimTarget);
606 coerceValue(value, myDefaultUdimTarget);
610 coerceValue(value, myRects.entries());
611 else if (instance[0] < myRects.entries())
613 auto && _data = myRects(instance[0]);
617 coerceValue(value, _data.rect_use);
620 coerceValue(value, _data.rect_center);
623 coerceValue(value, _data.rect_size);
630 coerceValue(value, myTileSize);
633 coerceValue(value, myNumColumns);
636 coerceValue(value, myStartingUdim);
639 coerceValue(value, myTargetUVAttr);
642 coerceValue(value, myTargetProjPlane);
645 coerceValue(value, myTargetGroup);
648 coerceValue(value, myTargetSeparatorEdges);
651 coerceValue(value, myUseTargetIslandAttr);
654 coerceValue(value, myTargetIslandAttr);
657 coerceValue(value, myStackIslands);
660 coerceValue(value, myStackMirrored);
663 coerceValue(value, myStackOnNonGroup);
666 coerceValue(value, myStackingLengthTolerance);
669 coerceValue(value, myGenerateNonpackedPolys);
672 coerceValue(value, myNonpackedPolys);
675 coerceValue(value, myGenerateIslandAttr);
678 coerceValue(value, myOutputIslandAttr);
681 coerceValue(value, myGenerateTargetAttr);
684 coerceValue(value, myOutputTargetAttr);
691 { doGetParmValue(idx, instance, value); }
693 { doGetParmValue(idx, instance, value); }
695 { doGetParmValue(idx, instance, value); }
697 { doGetParmValue(idx, instance, value); }
699 { doGetParmValue(idx, instance, value); }
701 { doGetParmValue(idx, instance, value); }
703 { doGetParmValue(idx, instance, value); }
705 { doGetParmValue(idx, instance, value); }
707 { doGetParmValue(idx, instance, value); }
709 { doGetParmValue(idx, instance, value); }
711 { doGetParmValue(idx, instance, value); }
713 template <
typename T>
720 if (idx.
size() != instance.
size()+1)
725 coerceValue(myUVAttr, value);
728 coerceValue(myUVProjPlane, value);
731 coerceValue(myGroup, value);
734 coerceValue(mySeparatorEdges, value);
737 coerceValue(myUseIslandAttr, value);
740 coerceValue(myIslandAttr, value);
743 coerceValue(myUseTargetAttr, value);
746 coerceValue(myTargetAttr, value);
749 coerceValue(myTargetOverrides, value);
752 coerceValue(myUseIslandScaleAttr, value);
755 coerceValue(myIslandScaleAttr, value);
758 coerceValue(myScaleOverrides, value);
761 coerceValue(myUseIslandOffsetAttr, value);
764 coerceValue(myIslandOffsetAttr, value);
767 coerceValue(myOffsetOverrides, value);
770 coerceValue(myCorrectAreas, value);
773 coerceValue(myAxisAlignment, value);
776 coerceValue(myScaling, value);
779 coerceValue(myScale, value);
782 coerceValue(myRotationStep, value);
785 coerceValue(myCircleDivs, value);
788 coerceValue(myPackBetween, value);
791 coerceValue(myPackInCavities, value);
794 coerceValue(myPadding, value);
797 coerceValue(myPadBoundaries, value);
800 coerceValue(myExpandPadding, value);
803 coerceValue(myIterations, value);
806 coerceValue(myResolution, value);
809 coerceValue(myCustomResolution, value);
812 coerceValue(myConnectivityTolerance, value);
815 coerceValue(myScaleTolerance, value);
818 coerceValue(myRandSeed, value);
821 coerceValue(myTargetType, value);
824 coerceValue(myUseDefaultTarget, value);
827 coerceValue(myDefaultTarget, value);
830 coerceValue(myUseDefaultUdimTarget, value);
833 coerceValue(myDefaultUdimTarget, value);
839 coerceValue(newsize, value);
840 myRects.setSize(newsize);
844 myRects.setSizeIfNeeded(instance[0]+1);
845 auto && _data = myRects(instance[0]);
849 coerceValue(_data.rect_use, value);
852 coerceValue(_data.rect_center, value);
855 coerceValue(_data.rect_size, value);
862 coerceValue(myTileSize, value);
865 coerceValue(myNumColumns, value);
868 coerceValue(myStartingUdim, value);
871 coerceValue(myTargetUVAttr, value);
874 coerceValue(myTargetProjPlane, value);
877 coerceValue(myTargetGroup, value);
880 coerceValue(myTargetSeparatorEdges, value);
883 coerceValue(myUseTargetIslandAttr, value);
886 coerceValue(myTargetIslandAttr, value);
889 coerceValue(myStackIslands, value);
892 coerceValue(myStackMirrored, value);
895 coerceValue(myStackOnNonGroup, value);
898 coerceValue(myStackingLengthTolerance, value);
901 coerceValue(myGenerateNonpackedPolys, value);
904 coerceValue(myNonpackedPolys, value);
907 coerceValue(myGenerateIslandAttr, value);
910 coerceValue(myOutputIslandAttr, value);
913 coerceValue(myGenerateTargetAttr, value);
916 coerceValue(myOutputTargetAttr, value);
923 { doSetParmValue(idx, instance, value); }
925 { doSetParmValue(idx, instance, value); }
927 { doSetParmValue(idx, instance, value); }
929 { doSetParmValue(idx, instance, value); }
931 { doSetParmValue(idx, instance, value); }
933 { doSetParmValue(idx, instance, value); }
935 { doSetParmValue(idx, instance, value); }
937 { doSetParmValue(idx, instance, value); }
939 { doSetParmValue(idx, instance, value); }
941 { doSetParmValue(idx, instance, value); }
943 { doSetParmValue(idx, instance, value); }
961 if (fieldnum.
size() < 1)
972 return "separatoredges";
974 return "useislandattr";
978 return "usetargetattr";
982 return "targetoverrides";
984 return "useislandscaleattr";
986 return "islandscaleattr";
988 return "scaleoverrides";
990 return "useislandsetattr";
992 return "islandoffsetattr";
994 return "offsetoverrides";
996 return "correctareas";
998 return "axisalignislands";
1006 return "circledivs";
1008 return "packbetween";
1010 return "packincavities";
1014 return "paddingboundary";
1016 return "expandpadding";
1018 return "iterations";
1020 return "resolution";
1022 return "customresolution";
1024 return "uvtolerance";
1026 return "scaletolerance";
1030 return "targettype";
1032 return "usedefaulttarget";
1034 return "defaulttarget";
1036 return "usedefaultudimtarget";
1038 return "defaultudimtarget";
1040 if (fieldnum.
size() == 1)
1042 switch (fieldnum[1])
1047 return "rect_center#";
1049 return "rect_size#";
1056 return "numcolumns";
1058 return "startingudim";
1060 return "targetuvattrib";
1062 return "targetprojplane";
1064 return "targetgroup";
1066 return "targetseparatoredges";
1068 return "usetargetislandattr";
1070 return "targetislandattr";
1072 return "stackislands";
1074 return "invertedoverlays";
1076 return "stackonnongroup";
1078 return "overlaytolerance";
1080 return "generatenonpackedpoly";
1082 return "nonpackedpolys";
1084 return "generateislandattr";
1086 return "outputislandattr";
1088 return "generatetargetattr";
1090 return "outputtargetattr";
1098 if (fieldnum.
size() < 1)
1099 return PARM_UNSUPPORTED;
1100 switch (fieldnum[0])
1105 return PARM_INTEGER;
1111 return PARM_INTEGER;
1115 return PARM_INTEGER;
1121 return PARM_INTEGER;
1127 return PARM_INTEGER;
1133 return PARM_INTEGER;
1135 return PARM_INTEGER;
1137 return PARM_INTEGER;
1141 return PARM_INTEGER;
1143 return PARM_INTEGER;
1145 return PARM_INTEGER;
1147 return PARM_INTEGER;
1149 return PARM_INTEGER;
1151 return PARM_INTEGER;
1153 return PARM_INTEGER;
1155 return PARM_INTEGER;
1157 return PARM_INTEGER;
1159 return PARM_INTEGER;
1165 return PARM_INTEGER;
1167 return PARM_INTEGER;
1169 return PARM_INTEGER;
1171 return PARM_INTEGER;
1173 return PARM_INTEGER;
1175 return PARM_INTEGER;
1177 if (fieldnum.
size() == 1)
1178 return PARM_MULTIPARM;
1179 switch (fieldnum[1])
1182 return PARM_INTEGER;
1184 return PARM_VECTOR2;
1186 return PARM_VECTOR2;
1189 return PARM_UNSUPPORTED;
1191 return PARM_VECTOR2;
1193 return PARM_INTEGER;
1195 return PARM_INTEGER;
1199 return PARM_INTEGER;
1205 return PARM_INTEGER;
1209 return PARM_INTEGER;
1211 return PARM_INTEGER;
1213 return PARM_INTEGER;
1217 return PARM_INTEGER;
1221 return PARM_INTEGER;
1225 return PARM_INTEGER;
1230 return PARM_UNSUPPORTED;
1235 { is.
bread(&v, 1); }
1266 loadData(is, rampdata);
1284 int typelen = colon - data.
buffer();
1296 { UTwrite(os, &v); }
1298 {
int64 iv =
v; UTwrite(os, &iv); }
1300 { UTwrite<fpreal64>(os, &
v); }
1302 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
1304 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1305 UTwrite<fpreal64>(os, &v.
z()); }
1307 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1308 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
1320 if (s) s->save(ostr);
1321 result = ostr.
str();
1322 saveData(os, result);
1329 ostr << s->getDataTypeToken();
1331 s->saveBinary(ostr);
1333 result = ostr.
str();
1334 saveData(os, result);
1342 saveData(os, myUVAttr);
1343 saveData(os, myUVProjPlane);
1344 saveData(os, myGroup);
1345 saveData(os, mySeparatorEdges);
1346 saveData(os, myUseIslandAttr);
1347 saveData(os, myIslandAttr);
1348 saveData(os, myUseTargetAttr);
1349 saveData(os, myTargetAttr);
1350 saveData(os, myTargetOverrides);
1351 saveData(os, myUseIslandScaleAttr);
1352 saveData(os, myIslandScaleAttr);
1353 saveData(os, myScaleOverrides);
1354 saveData(os, myUseIslandOffsetAttr);
1355 saveData(os, myIslandOffsetAttr);
1356 saveData(os, myOffsetOverrides);
1357 saveData(os, myCorrectAreas);
1358 saveData(os, myAxisAlignment);
1359 saveData(os, myScaling);
1360 saveData(os, myScale);
1361 saveData(os, myRotationStep);
1362 saveData(os, myCircleDivs);
1363 saveData(os, myPackBetween);
1364 saveData(os, myPackInCavities);
1365 saveData(os, myPadding);
1366 saveData(os, myPadBoundaries);
1367 saveData(os, myExpandPadding);
1368 saveData(os, myIterations);
1369 saveData(os, myResolution);
1370 saveData(os, myCustomResolution);
1371 saveData(os, myConnectivityTolerance);
1372 saveData(os, myScaleTolerance);
1373 saveData(os, myRandSeed);
1374 saveData(os, myTargetType);
1375 saveData(os, myUseDefaultTarget);
1376 saveData(os, myDefaultTarget);
1377 saveData(os, myUseDefaultUdimTarget);
1378 saveData(os, myDefaultUdimTarget);
1381 UTwrite(os, &length);
1384 saveData(os, myRects(i).rect_use);
1385 saveData(os, myRects(i).rect_center);
1386 saveData(os, myRects(i).rect_size);
1390 saveData(os, myTileSize);
1391 saveData(os, myNumColumns);
1392 saveData(os, myStartingUdim);
1393 saveData(os, myTargetUVAttr);
1394 saveData(os, myTargetProjPlane);
1395 saveData(os, myTargetGroup);
1396 saveData(os, myTargetSeparatorEdges);
1397 saveData(os, myUseTargetIslandAttr);
1398 saveData(os, myTargetIslandAttr);
1399 saveData(os, myStackIslands);
1400 saveData(os, myStackMirrored);
1401 saveData(os, myStackOnNonGroup);
1402 saveData(os, myStackingLengthTolerance);
1403 saveData(os, myGenerateNonpackedPolys);
1404 saveData(os, myNonpackedPolys);
1405 saveData(os, myGenerateIslandAttr);
1406 saveData(os, myOutputIslandAttr);
1407 saveData(os, myGenerateTargetAttr);
1408 saveData(os, myOutputTargetAttr);
1421 loadData(is, myUVAttr);
1422 loadData(is, myUVProjPlane);
1423 loadData(is, myGroup);
1424 loadData(is, mySeparatorEdges);
1425 loadData(is, myUseIslandAttr);
1426 loadData(is, myIslandAttr);
1427 loadData(is, myUseTargetAttr);
1428 loadData(is, myTargetAttr);
1429 loadData(is, myTargetOverrides);
1430 loadData(is, myUseIslandScaleAttr);
1431 loadData(is, myIslandScaleAttr);
1432 loadData(is, myScaleOverrides);
1433 loadData(is, myUseIslandOffsetAttr);
1434 loadData(is, myIslandOffsetAttr);
1435 loadData(is, myOffsetOverrides);
1436 loadData(is, myCorrectAreas);
1437 loadData(is, myAxisAlignment);
1438 loadData(is, myScaling);
1439 loadData(is, myScale);
1440 loadData(is, myRotationStep);
1441 loadData(is, myCircleDivs);
1442 loadData(is, myPackBetween);
1443 loadData(is, myPackInCavities);
1444 loadData(is, myPadding);
1445 loadData(is, myPadBoundaries);
1446 loadData(is, myExpandPadding);
1447 loadData(is, myIterations);
1448 loadData(is, myResolution);
1449 loadData(is, myCustomResolution);
1450 loadData(is, myConnectivityTolerance);
1451 loadData(is, myScaleTolerance);
1452 loadData(is, myRandSeed);
1453 loadData(is, myTargetType);
1454 loadData(is, myUseDefaultTarget);
1455 loadData(is, myDefaultTarget);
1456 loadData(is, myUseDefaultUdimTarget);
1457 loadData(is, myDefaultUdimTarget);
1460 is.
read(&length, 1);
1461 myRects.entries(length);
1464 loadData(is, myRects(i).rect_use);
1465 loadData(is, myRects(i).rect_center);
1466 loadData(is, myRects(i).rect_size);
1470 loadData(is, myTileSize);
1471 loadData(is, myNumColumns);
1472 loadData(is, myStartingUdim);
1473 loadData(is, myTargetUVAttr);
1474 loadData(is, myTargetProjPlane);
1475 loadData(is, myTargetGroup);
1476 loadData(is, myTargetSeparatorEdges);
1477 loadData(is, myUseTargetIslandAttr);
1478 loadData(is, myTargetIslandAttr);
1479 loadData(is, myStackIslands);
1480 loadData(is, myStackMirrored);
1481 loadData(is, myStackOnNonGroup);
1482 loadData(is, myStackingLengthTolerance);
1483 loadData(is, myGenerateNonpackedPolys);
1484 loadData(is, myNonpackedPolys);
1485 loadData(is, myGenerateIslandAttr);
1486 loadData(is, myOutputIslandAttr);
1487 loadData(is, myGenerateTargetAttr);
1488 loadData(is, myOutputTargetAttr);
1498 if (!thissop)
return getUVAttr();
1500 OP_Utils::evalOpParm(result, thissop,
"uvattrib", cookparms.
getCookTime(), 0);
1508 if (!thissop)
return getUVProjPlane();
1510 OP_Utils::evalOpParm(result, thissop,
"projplane", cookparms.
getCookTime(), 0);
1518 if (!thissop)
return getGroup();
1520 OP_Utils::evalOpParm(result, thissop,
"group", cookparms.
getCookTime(), 0);
1528 if (!thissop)
return getSeparatorEdges();
1530 OP_Utils::evalOpParm(result, thissop,
"separatoredges", cookparms.
getCookTime(), 0);
1538 if (!thissop)
return getUseIslandAttr();
1540 OP_Utils::evalOpParm(result, thissop,
"useislandattr", cookparms.
getCookTime(), 0);
1548 if (!thissop)
return getIslandAttr();
1550 OP_Utils::evalOpParm(result, thissop,
"islandattr", cookparms.
getCookTime(), 0);
1558 if (!thissop)
return getUseTargetAttr();
1560 OP_Utils::evalOpParm(result, thissop,
"usetargetattr", cookparms.
getCookTime(), 0);
1568 if (!thissop)
return getTargetAttr();
1570 OP_Utils::evalOpParm(result, thissop,
"targetattr", cookparms.
getCookTime(), 0);
1578 if (!thissop)
return getTargetOverrides();
1580 OP_Utils::evalOpParm(result, thissop,
"targetoverrides", cookparms.
getCookTime(), 0);
1588 if (!thissop)
return getUseIslandScaleAttr();
1590 OP_Utils::evalOpParm(result, thissop,
"useislandscaleattr", cookparms.
getCookTime(), 0);
1598 if (!thissop)
return getIslandScaleAttr();
1600 OP_Utils::evalOpParm(result, thissop,
"islandscaleattr", cookparms.
getCookTime(), 0);
1608 if (!thissop)
return getScaleOverrides();
1610 OP_Utils::evalOpParm(result, thissop,
"scaleoverrides", cookparms.
getCookTime(), 0);
1618 if (!thissop)
return getUseIslandOffsetAttr();
1620 OP_Utils::evalOpParm(result, thissop,
"useislandsetattr", cookparms.
getCookTime(), 0);
1628 if (!thissop)
return getIslandOffsetAttr();
1630 OP_Utils::evalOpParm(result, thissop,
"islandoffsetattr", cookparms.
getCookTime(), 0);
1638 if (!thissop)
return getOffsetOverrides();
1640 OP_Utils::evalOpParm(result, thissop,
"offsetoverrides", cookparms.
getCookTime(), 0);
1648 if (!thissop)
return getCorrectAreas();
1650 OP_Utils::evalOpParm(result, thissop,
"correctareas", cookparms.
getCookTime(), 0);
1658 if (!thissop)
return getAxisAlignment();
1660 OP_Utils::evalOpParm(result, thissop,
"axisalignislands", cookparms.
getCookTime(), 0);
1668 if (!thissop)
return getScaling();
1670 OP_Utils::evalOpParm(result, thissop,
"scaling", cookparms.
getCookTime(), 0);
1680 OP_Utils::evalOpParm(result, thissop,
"scale", cookparms.
getCookTime(), 0);
1688 if (!thissop)
return getRotationStep();
1690 OP_Utils::evalOpParm(result, thissop,
"rotstep", cookparms.
getCookTime(), 0);
1698 if (!thissop)
return getCircleDivs();
1700 OP_Utils::evalOpParm(result, thissop,
"circledivs", cookparms.
getCookTime(), 0);
1708 if (!thissop)
return getPackBetween();
1710 OP_Utils::evalOpParm(result, thissop,
"packbetween", cookparms.
getCookTime(), 0);
1718 if (!thissop)
return getPackInCavities();
1720 OP_Utils::evalOpParm(result, thissop,
"packincavities", cookparms.
getCookTime(), 0);
1728 if (!thissop)
return getPadding();
1730 OP_Utils::evalOpParm(result, thissop,
"padding", cookparms.
getCookTime(), 0);
1738 if (!thissop)
return getPadBoundaries();
1740 OP_Utils::evalOpParm(result, thissop,
"paddingboundary", cookparms.
getCookTime(), 0);
1748 if (!thissop)
return getExpandPadding();
1750 OP_Utils::evalOpParm(result, thissop,
"expandpadding", cookparms.
getCookTime(), 0);
1758 if (!thissop)
return getIterations();
1760 OP_Utils::evalOpParm(result, thissop,
"iterations", cookparms.
getCookTime(), 0);
1768 if (!thissop)
return getResolution();
1770 OP_Utils::evalOpParm(result, thissop,
"resolution", cookparms.
getCookTime(), 0);
1778 if (!thissop)
return getCustomResolution();
1780 OP_Utils::evalOpParm(result, thissop,
"customresolution", cookparms.
getCookTime(), 0);
1788 if (!thissop)
return getConnectivityTolerance();
1790 OP_Utils::evalOpParm(result, thissop,
"uvtolerance", cookparms.
getCookTime(), 0);
1798 if (!thissop)
return getScaleTolerance();
1800 OP_Utils::evalOpParm(result, thissop,
"scaletolerance", cookparms.
getCookTime(), 0);
1808 if (!thissop)
return getRandSeed();
1810 OP_Utils::evalOpParm(result, thissop,
"randseed", cookparms.
getCookTime(), 0);
1818 if (!thissop)
return getTargetType();
1820 OP_Utils::evalOpParm(result, thissop,
"targettype", cookparms.
getCookTime(), 0);
1828 if (!thissop)
return getUseDefaultTarget();
1830 OP_Utils::evalOpParm(result, thissop,
"usedefaulttarget", cookparms.
getCookTime(), 0);
1838 if (!thissop)
return getDefaultTarget();
1840 OP_Utils::evalOpParm(result, thissop,
"defaulttarget", cookparms.
getCookTime(), 0);
1848 if (!thissop)
return getUseDefaultUdimTarget();
1850 OP_Utils::evalOpParm(result, thissop,
"usedefaultudimtarget", cookparms.
getCookTime(), 0);
1858 if (!thissop)
return getDefaultUdimTarget();
1860 OP_Utils::evalOpParm(result, thissop,
"defaultudimtarget", cookparms.
getCookTime(), 0);
1868 if (!thissop)
return getRects().entries();
1870 OP_Utils::evalOpParm(result, thissop,
"rects", cookparms.
getCookTime(), 0);
1876 if (!thissop)
return (myRects(_idx).rect_use);
1877 int _parmidx = _idx + 0;
1879 OP_Utils::evalOpParmInst(result, thissop,
"rect_use#", &_parmidx, cookparms.
getCookTime(), 0);
1885 if (!thissop)
return (myRects(_idx).rect_center);
1886 int _parmidx = _idx + 0;
1888 OP_Utils::evalOpParmInst(result, thissop,
"rect_center#", &_parmidx, cookparms.
getCookTime(), 0);
1894 if (!thissop)
return (myRects(_idx).rect_size);
1895 int _parmidx = _idx + 0;
1897 OP_Utils::evalOpParmInst(result, thissop,
"rect_size#", &_parmidx, cookparms.
getCookTime(), 0);
1906 if (!thissop)
return getTileSize();
1908 OP_Utils::evalOpParm(result, thissop,
"tilesize", cookparms.
getCookTime(), 0);
1916 if (!thissop)
return getNumColumns();
1918 OP_Utils::evalOpParm(result, thissop,
"numcolumns", cookparms.
getCookTime(), 0);
1926 if (!thissop)
return getStartingUdim();
1928 OP_Utils::evalOpParm(result, thissop,
"startingudim", cookparms.
getCookTime(), 0);
1936 if (!thissop)
return getTargetUVAttr();
1938 OP_Utils::evalOpParm(result, thissop,
"targetuvattrib", cookparms.
getCookTime(), 0);
1946 if (!thissop)
return getTargetProjPlane();
1948 OP_Utils::evalOpParm(result, thissop,
"targetprojplane", cookparms.
getCookTime(), 0);
1956 if (!thissop)
return getTargetGroup();
1958 OP_Utils::evalOpParm(result, thissop,
"targetgroup", cookparms.
getCookTime(), 0);
1966 if (!thissop)
return getTargetSeparatorEdges();
1968 OP_Utils::evalOpParm(result, thissop,
"targetseparatoredges", cookparms.
getCookTime(), 0);
1976 if (!thissop)
return getUseTargetIslandAttr();
1978 OP_Utils::evalOpParm(result, thissop,
"usetargetislandattr", cookparms.
getCookTime(), 0);
1986 if (!thissop)
return getTargetIslandAttr();
1988 OP_Utils::evalOpParm(result, thissop,
"targetislandattr", cookparms.
getCookTime(), 0);
1996 if (!thissop)
return getStackIslands();
1998 OP_Utils::evalOpParm(result, thissop,
"stackislands", cookparms.
getCookTime(), 0);
2006 if (!thissop)
return getStackMirrored();
2008 OP_Utils::evalOpParm(result, thissop,
"invertedoverlays", cookparms.
getCookTime(), 0);
2016 if (!thissop)
return getStackOnNonGroup();
2018 OP_Utils::evalOpParm(result, thissop,
"stackonnongroup", cookparms.
getCookTime(), 0);
2026 if (!thissop)
return getStackingLengthTolerance();
2028 OP_Utils::evalOpParm(result, thissop,
"overlaytolerance", cookparms.
getCookTime(), 0);
2036 if (!thissop)
return getGenerateNonpackedPolys();
2038 OP_Utils::evalOpParm(result, thissop,
"generatenonpackedpoly", cookparms.
getCookTime(), 0);
2046 if (!thissop)
return getNonpackedPolys();
2048 OP_Utils::evalOpParm(result, thissop,
"nonpackedpolys", cookparms.
getCookTime(), 0);
2056 if (!thissop)
return getGenerateIslandAttr();
2058 OP_Utils::evalOpParm(result, thissop,
"generateislandattr", cookparms.
getCookTime(), 0);
2066 if (!thissop)
return getOutputIslandAttr();
2068 OP_Utils::evalOpParm(result, thissop,
"outputislandattr", cookparms.
getCookTime(), 0);
2076 if (!thissop)
return getGenerateTargetAttr();
2078 OP_Utils::evalOpParm(result, thissop,
"generatetargetattr", cookparms.
getCookTime(), 0);
2086 if (!thissop)
return getOutputTargetAttr();
2088 OP_Utils::evalOpParm(result, thissop,
"outputtargetattr", cookparms.
getCookTime(), 0);
2094 int64 myUVProjPlane;
2097 bool myUseIslandAttr;
2099 bool myUseTargetAttr;
2102 bool myUseIslandScaleAttr;
2105 bool myUseIslandOffsetAttr;
2108 bool myCorrectAreas;
2109 int64 myAxisAlignment;
2112 int64 myRotationStep;
2115 bool myPackInCavities;
2117 bool myPadBoundaries;
2118 bool myExpandPadding;
2121 int64 myCustomResolution;
2126 bool myUseDefaultTarget;
2127 int64 myDefaultTarget;
2128 bool myUseDefaultUdimTarget;
2129 int64 myDefaultUdimTarget;
2133 int64 myStartingUdim;
2135 int64 myTargetProjPlane;
2138 bool myUseTargetIslandAttr;
2140 bool myStackIslands;
2141 bool myStackMirrored;
2142 bool myStackOnNonGroup;
2143 fpreal64 myStackingLengthTolerance;
2144 bool myGenerateNonpackedPolys;
2146 bool myGenerateIslandAttr;
2148 bool myGenerateTargetAttr;
void setIslandScaleAttr(const UT_StringHolder &val)
void setStackOnNonGroup(bool val)
TargetType getTargetType() const
bool getCorrectAreas() const
void loadFromOpSubclass(const LoadParms &loadparms) override
bool opRects_rect_use(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void setUVProjPlane(UVProjPlane val)
void setPackBetween(bool val)
fpreal64 getScale() const
void setStackingLengthTolerance(fpreal64 val)
bool opGenerateTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
void setTargetAttr(const UT_StringHolder &val)
const UT_StringHolder & getTargetUVAttr() const
void setGenerateTargetAttr(bool val)
SOP_Node * getNode() const
const UT_StringHolder & getTargetIslandAttr() const
void setTargetType(TargetType val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
UT_StringHolder opScaleOverrides(const SOP_NodeVerb::CookParms &cookparms) const
virtual void evalOpParmInst(int64 &v, NodeIdx node, const char *parmname, int *inst, fpreal time, DEP_MicroNode *depnode) const =0
void setStartingUdim(int64 val)
~SOP_UVLayout_3_0Parms() override
virtual NodeIdx getInput(NodeIdx idx, int input, bool markused=false) const =0
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
bool getPackInCavities() const
const UT_StringHolder & getUVAttr() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
UT_Vector2T< fpreal64 > UT_Vector2D
static void saveData(std::ostream &os, fpreal64 v)
GLuint const GLfloat * val
UT_Vector2D opRects_rect_size(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
const UT_StringHolder & getIslandScaleAttr() const
bool operator!=(const Rects &src) const
void setTargetOverrides(const UT_StringHolder &val)
bool opStackOnNonGroup(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargetSeparatorEdges(const SOP_NodeVerb::CookParms &cookparms) const
bool operator!=(const SOP_UVLayout_3_0Parms &src) const
void setScale(fpreal64 val)
void setOutputIslandAttr(const UT_StringHolder &val)
bool opUseIslandOffsetAttr(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void setScaling(Scaling val)
bool opPadBoundaries(const SOP_NodeVerb::CookParms &cookparms) const
void setRotationStep(RotationStep val)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
fpreal64 opConnectivityTolerance(const SOP_NodeVerb::CookParms &cookparms) const
const UT_Array< Rects > & getRects() const
bool opCorrectAreas(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_StringHolder s)
void setDefaultTarget(int64 val)
SYS_FORCE_INLINE const char * buffer() const
fpreal64 getStackingLengthTolerance() const
const SOP_GraphProxy * graph() const
bool getUseTargetIslandAttr() const
void setIterations(int64 val)
void setPackInCavities(bool val)
RotationStep getRotationStep() const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
An output stream object that owns its own string buffer storage.
static void loadData(UT_IStream &is, int64 &v)
void setNumColumns(int64 val)
UT_Vector2D getTileSize() const
const char * getNestParmName(TempIndex fieldnum) const override
int64 getIterations() const
static void loadData(UT_IStream &is, UT_Vector2I &v)
UVProjPlane opUVProjPlane(const SOP_NodeVerb::CookParms &cookparms) const
int64 opDefaultUdimTarget(const SOP_NodeVerb::CookParms &cookparms) const
void setCustomResolution(int64 val)
UT_StringHolder opTargetIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
bool opStackMirrored(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_StringHolder & getTargetSeparatorEdges() const
bool getUseIslandScaleAttr() const
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
bool opUseDefaultUdimTarget(const SOP_NodeVerb::CookParms &cookparms) const
int64 opIterations(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
const UT_StringHolder & getSeparatorEdges() const
bool getUseDefaultTarget() const
void setGenerateNonpackedPolys(bool val)
void setPadding(int64 val)
bool opStackIslands(const SOP_NodeVerb::CookParms &cookparms) const
void setDefaultUdimTarget(int64 val)
static void loadData(UT_IStream &is, UT_Vector3I &v)
RotationStep opRotationStep(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
bool getGenerateNonpackedPolys() const
bool getStackIslands() const
bool getUseTargetAttr() const
bool opUseTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
void setGenerateIslandAttr(bool val)
static void loadData(UT_IStream &is, fpreal64 &v)
int64 opNumColumns(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getTargetGroup() const
void setCircleDivs(int64 val)
int64 opPadding(const SOP_NodeVerb::CookParms &cookparms) const
void setConnectivityTolerance(fpreal64 val)
UT_StringHolder opSeparatorEdges(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
void setResolution(Resolution val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
void setExpandPadding(bool val)
static void loadData(UT_IStream &is, UT_Vector4D &v)
void setScaleTolerance(fpreal64 val)
UT_Vector2D opRects_rect_center(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
bool opExpandPadding(const SOP_NodeVerb::CookParms &cookparms) const
AxisAlignment opAxisAlignment(const SOP_NodeVerb::CookParms &cookparms) const
void setRandSeed(int64 val)
SYS_FORCE_INLINE const char * buffer() const
UT_StringHolder opTargetUVAttr(const SOP_NodeVerb::CookParms &cookparms) const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
bool opPackInCavities(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, bool &v)
static void saveData(std::ostream &os, bool v)
fpreal64 opScale(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2D opTileSize(const SOP_NodeVerb::CookParms &cookparms) const
GLint GLenum GLsizei GLint GLsizei const void * data
bool load(UT_IStream &is)
static void saveData(std::ostream &os, UT_Vector2D v)
void setUseIslandScaleAttr(bool val)
exint read(bool *array, exint sz=1)
UT_StringHolder opIslandScaleAttr(const SOP_NodeVerb::CookParms &cookparms) const
exint getNestNumParms(TempIndex idx) const override
void setStackIslands(bool val)
UT_StringHolder opNonpackedPolys(const SOP_NodeVerb::CookParms &cookparms) const
void setUseIslandOffsetAttr(bool val)
GLuint GLsizei GLsizei * length
bool opGenerateNonpackedPolys(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
void setIslandAttr(const UT_StringHolder &val)
int64 getNumColumns() const
UT_StringHolder opIslandOffsetAttr(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
const UT_StringHolder & getOutputTargetAttr() const
int64 getCustomResolution() const
int64 getDefaultUdimTarget() const
void setGroup(const UT_StringHolder &val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
bool getUseIslandOffsetAttr() const
TargetType opTargetType(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
UT_StringHolder opIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
UVProjPlane getUVProjPlane() const
Resolution getResolution() const
bool opUseTargetIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getOffsetOverrides() const
UT_StringHolder opOutputIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
TargetProjPlane getTargetProjPlane() const
void copyFrom(const SOP_NodeParms *src) override
bool getGenerateIslandAttr() const
static void saveData(std::ostream &os, UT_Vector3D v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
static void saveData(std::ostream &os, UT_Vector4D v)
SYS_FORCE_INLINE void strcat(const char *src)
void saveBinary(std::ostream &os) const
Save string to binary stream.
bool getUseDefaultUdimTarget() const
const UT_StringHolder & getGroup() const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void setTargetUVAttr(const UT_StringHolder &val)
bool operator==(const Rects &src) const
int64 getStartingUdim() const
void save(std::ostream &os) const
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
void setTileSize(UT_Vector2D val)
bool opPackBetween(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseDefaultTarget(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargetGroup(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix3D v)
int64 opRandSeed(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
exint entries() const
Alias of size(). size() is preferred.
static void loadData(UT_IStream &is, UT_Matrix4D &v)
bool opUseIslandScaleAttr(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseIslandAttr() const
Scaling getScaling() const
void setUseDefaultTarget(bool val)
int64 getDefaultTarget() const
fpreal64 opScaleTolerance(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setOutputTargetAttr(const UT_StringHolder &val)
int int appendSprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
bool getPackBetween() const
exint opRects(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opTargetOverrides(const SOP_NodeVerb::CookParms &cookparms) const
void setStackMirrored(bool val)
const UT_StringHolder & getIslandOffsetAttr() const
const UT_StringHolder & getOutputIslandAttr() const
const UT_StringHolder & getNonpackedPolys() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
UT_StringHolder opOffsetOverrides(const SOP_NodeVerb::CookParms &cookparms) const
void setUseTargetAttr(bool val)
static void saveData(std::ostream &os, UT_Matrix2D v)
UT_StringHolder opOutputTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
int64 getCircleDivs() const
void setRects(const UT_Array< Rects > &val)
Utility class for containing a color ramp.
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
void setNonpackedPolys(const UT_StringHolder &val)
int64 opStartingUdim(const SOP_NodeVerb::CookParms &cookparms) const
bool getGenerateTargetAttr() const
static void loadData(UT_IStream &is, UT_Vector3D &v)
SYS_FORCE_INLINE void append(char character)
GLdouble GLdouble GLdouble r
Vec3< typename MatType::value_type > getScale(const MatType &mat)
Return a Vec3 representing the lengths of the passed matrix's upper 3×3's rows.
void setScaleOverrides(const UT_StringHolder &val)
fpreal64 getConnectivityTolerance() const
static void loadData(UT_IStream &is, UT_StringHolder &v)
const UT_StringHolder & getTargetOverrides() const
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
void setTargetSeparatorEdges(const UT_StringHolder &val)
fpreal getCookTime() const
fpreal64 opStackingLengthTolerance(const SOP_NodeVerb::CookParms &cookparms) const
ParmType getNestParmType(TempIndex fieldnum) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
void setSeparatorEdges(const UT_StringHolder &val)
const UT_StringHolder & getIslandAttr() const
void setCorrectAreas(bool val)
AxisAlignment getAxisAlignment() const
void setPadBoundaries(bool val)
static void saveData(std::ostream &os, UT_Matrix4D v)
UT_StringHolder opUVAttr(const SOP_NodeVerb::CookParms &cookparms) const
const char * findChar(int c) const
void setTargetProjPlane(TargetProjPlane val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
bool getStackOnNonGroup() const
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
Resolution opResolution(const SOP_NodeVerb::CookParms &cookparms) const
void setIslandOffsetAttr(const UT_StringHolder &val)
bool opUseIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
bool opGenerateIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
void setOffsetOverrides(const UT_StringHolder &val)
void setUVAttr(const UT_StringHolder &val)
static void saveData(std::ostream &os, int64 v)
bool getPadBoundaries() const
Scaling opScaling(const SOP_NodeVerb::CookParms &cookparms) const
int64 opDefaultTarget(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
UT_StringHolder opTargetAttr(const SOP_NodeVerb::CookParms &cookparms) const
GLenum GLuint GLsizei const GLchar * buf
TargetProjPlane opTargetProjPlane(const SOP_NodeVerb::CookParms &cookparms) const
bool getExpandPadding() const
void setTargetIslandAttr(const UT_StringHolder &val)
GLsizei const GLfloat * value
const UT_StringHolder & getTargetAttr() const
void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
const OP_Context & context() const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
int64 getRandSeed() const
void setAxisAlignment(AxisAlignment val)
int64 opCustomResolution(const SOP_NodeVerb::CookParms &cookparms) const
void setUseTargetIslandAttr(bool val)
fpreal64 getScaleTolerance() const
SYS_FORCE_INLINE bool isstring() const
int64 opCircleDivs(const SOP_NodeVerb::CookParms &cookparms) const
void setUseIslandAttr(bool val)
bool getStackMirrored() const
const UT_StringHolder & getScaleOverrides() const
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
UT_StringHolder createString(const UT_Array< Rects > &list) const
bool operator==(const SOP_UVLayout_3_0Parms &src) const
void setUseDefaultUdimTarget(bool val)
void setTargetGroup(const UT_StringHolder &val)