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());
138 myUVAttr =
"uv"_UTsh;
141 mySeparatorEdges =
""_UTsh;
142 myUseIslandAttr =
false;
143 myIslandAttr =
"island"_UTsh;
144 myUseTargetAttr =
false;
145 myTargetAttr =
"udim"_UTsh;
146 myTargetOverrides =
""_UTsh;
147 myUseIslandScaleAttr =
false;
148 myIslandScaleAttr =
"iscale"_UTsh;
149 myScaleOverrides =
""_UTsh;
150 myUseIslandOffsetAttr =
false;
151 myIslandOffsetAttr =
"ioffset"_UTsh;
152 myOffsetOverrides =
""_UTsh;
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;
178 myStartingUdim = 1001;
179 myTargetUVAttr =
"uv"_UTsh;
180 myTargetProjPlane = 0;
181 myTargetGroup =
""_UTsh;
182 myTargetSeparatorEdges =
""_UTsh;
183 myUseTargetIslandAttr =
false;
184 myTargetIslandAttr =
"targetisland"_UTsh;
185 myStackIslands =
false;
186 myStackMirrored =
false;
187 myStackOnNonGroup =
false;
188 myStackingLengthTolerance = 0.02;
189 myGenerateNonpackedPolys =
false;
190 myNonpackedPolys =
"nonpacked"_UTsh;
191 myGenerateIslandAttr =
false;
192 myOutputIslandAttr =
"island"_UTsh;
193 myGenerateTargetAttr =
false;
194 myOutputTargetAttr =
"target"_UTsh;
207 if (myUVAttr != src.myUVAttr)
return false;
208 if (myUVProjPlane != src.myUVProjPlane)
return false;
209 if (myGroup != src.myGroup)
return false;
210 if (mySeparatorEdges != src.mySeparatorEdges)
return false;
211 if (myUseIslandAttr != src.myUseIslandAttr)
return false;
212 if (myIslandAttr != src.myIslandAttr)
return false;
213 if (myUseTargetAttr != src.myUseTargetAttr)
return false;
214 if (myTargetAttr != src.myTargetAttr)
return false;
215 if (myTargetOverrides != src.myTargetOverrides)
return false;
216 if (myUseIslandScaleAttr != src.myUseIslandScaleAttr)
return false;
217 if (myIslandScaleAttr != src.myIslandScaleAttr)
return false;
218 if (myScaleOverrides != src.myScaleOverrides)
return false;
219 if (myUseIslandOffsetAttr != src.myUseIslandOffsetAttr)
return false;
220 if (myIslandOffsetAttr != src.myIslandOffsetAttr)
return false;
221 if (myOffsetOverrides != src.myOffsetOverrides)
return false;
222 if (myCorrectAreas != src.myCorrectAreas)
return false;
223 if (myAxisAlignment != src.myAxisAlignment)
return false;
224 if (myScaling != src.myScaling)
return false;
225 if (myScale != src.myScale)
return false;
226 if (myRotationStep != src.myRotationStep)
return false;
227 if (myCircleDivs != src.myCircleDivs)
return false;
228 if (myPackBetween != src.myPackBetween)
return false;
229 if (myPackInCavities != src.myPackInCavities)
return false;
230 if (myPadding != src.myPadding)
return false;
231 if (myPadBoundaries != src.myPadBoundaries)
return false;
232 if (myExpandPadding != src.myExpandPadding)
return false;
233 if (myIterations != src.myIterations)
return false;
234 if (myResolution != src.myResolution)
return false;
235 if (myCustomResolution != src.myCustomResolution)
return false;
236 if (myConnectivityTolerance != src.myConnectivityTolerance)
return false;
237 if (myScaleTolerance != src.myScaleTolerance)
return false;
238 if (myRandSeed != src.myRandSeed)
return false;
239 if (myTargetType != src.myTargetType)
return false;
240 if (myUseDefaultTarget != src.myUseDefaultTarget)
return false;
241 if (myDefaultTarget != src.myDefaultTarget)
return false;
242 if (myUseDefaultUdimTarget != src.myUseDefaultUdimTarget)
return false;
243 if (myDefaultUdimTarget != src.myDefaultUdimTarget)
return false;
244 if (myRects != src.myRects)
return false;
245 if (myTileSize != src.myTileSize)
return false;
246 if (myNumColumns != src.myNumColumns)
return false;
247 if (myStartingUdim != src.myStartingUdim)
return false;
248 if (myTargetUVAttr != src.myTargetUVAttr)
return false;
249 if (myTargetProjPlane != src.myTargetProjPlane)
return false;
250 if (myTargetGroup != src.myTargetGroup)
return false;
251 if (myTargetSeparatorEdges != src.myTargetSeparatorEdges)
return false;
252 if (myUseTargetIslandAttr != src.myUseTargetIslandAttr)
return false;
253 if (myTargetIslandAttr != src.myTargetIslandAttr)
return false;
254 if (myStackIslands != src.myStackIslands)
return false;
255 if (myStackMirrored != src.myStackMirrored)
return false;
256 if (myStackOnNonGroup != src.myStackOnNonGroup)
return false;
257 if (myStackingLengthTolerance != src.myStackingLengthTolerance)
return false;
258 if (myGenerateNonpackedPolys != src.myGenerateNonpackedPolys)
return false;
259 if (myNonpackedPolys != src.myNonpackedPolys)
return false;
260 if (myGenerateIslandAttr != src.myGenerateIslandAttr)
return false;
261 if (myOutputIslandAttr != src.myOutputIslandAttr)
return false;
262 if (myGenerateTargetAttr != src.myGenerateTargetAttr)
return false;
263 if (myOutputTargetAttr != src.myOutputTargetAttr)
return false;
283 myUVAttr =
"uv"_UTsh;
285 graph->
evalOpParm(myUVAttr, nodeidx,
"uvattrib", time, 0);
288 graph->
evalOpParm(myUVProjPlane, nodeidx,
"projplane", time, 0);
291 graph->
evalOpParm(myGroup, nodeidx,
"group", time, 0);
292 mySeparatorEdges =
""_UTsh;
294 graph->
evalOpParm(mySeparatorEdges, nodeidx,
"separatoredges", time, 0);
295 myUseIslandAttr =
false;
297 graph->
evalOpParm(myUseIslandAttr, nodeidx,
"useislandattr", time, 0);
298 myIslandAttr =
"island"_UTsh;
299 if (
true && ( (
true&&!(((getUseIslandAttr()==0)))) ) )
300 graph->
evalOpParm(myIslandAttr, nodeidx,
"islandattr", time, 0);
301 myUseTargetAttr =
false;
303 graph->
evalOpParm(myUseTargetAttr, nodeidx,
"usetargetattr", time, 0);
304 myTargetAttr =
"udim"_UTsh;
305 if (
true && ( (
true&&!(((getUseTargetAttr()==0)))) ) )
306 graph->
evalOpParm(myTargetAttr, nodeidx,
"targetattr", time, 0);
307 myTargetOverrides =
""_UTsh;
309 graph->
evalOpParm(myTargetOverrides, nodeidx,
"targetoverrides", time, 0);
310 myUseIslandScaleAttr =
false;
312 graph->
evalOpParm(myUseIslandScaleAttr, nodeidx,
"useislandscaleattr", time, 0);
313 myIslandScaleAttr =
"iscale"_UTsh;
314 if (
true && ( (
true&&!(((getUseIslandScaleAttr()==0)))) ) )
315 graph->
evalOpParm(myIslandScaleAttr, nodeidx,
"islandscaleattr", time, 0);
316 myScaleOverrides =
""_UTsh;
318 graph->
evalOpParm(myScaleOverrides, nodeidx,
"scaleoverrides", time, 0);
319 myUseIslandOffsetAttr =
false;
321 graph->
evalOpParm(myUseIslandOffsetAttr, nodeidx,
"useislandsetattr", time, 0);
322 myIslandOffsetAttr =
"ioffset"_UTsh;
323 if (
true && ( (
true&&!(((getUseIslandOffsetAttr()==0)))) ) )
324 graph->
evalOpParm(myIslandOffsetAttr, nodeidx,
"islandoffsetattr", time, 0);
325 myOffsetOverrides =
""_UTsh;
327 graph->
evalOpParm(myOffsetOverrides, nodeidx,
"offsetoverrides", time, 0);
328 myCorrectAreas =
false;
330 graph->
evalOpParm(myCorrectAreas, nodeidx,
"correctareas", time, 0);
333 graph->
evalOpParm(myAxisAlignment, nodeidx,
"axisalignislands", time, 0);
336 graph->
evalOpParm(myScaling, nodeidx,
"scaling", time, 0);
338 if (
true && ( (
true&&!(((
int64(getScaling())!=1)))) ) )
339 graph->
evalOpParm(myScale, nodeidx,
"scale", time, 0);
342 graph->
evalOpParm(myRotationStep, nodeidx,
"rotstep", time, 0);
344 if (
true && ( (
true&&!(((
int64(getRotationStep())!=7)))) ) )
345 graph->
evalOpParm(myCircleDivs, nodeidx,
"circledivs", time, 0);
346 myPackBetween =
false;
348 graph->
evalOpParm(myPackBetween, nodeidx,
"packbetween", time, 0);
349 myPackInCavities =
true;
351 graph->
evalOpParm(myPackInCavities, nodeidx,
"packincavities", time, 0);
354 graph->
evalOpParm(myPadding, nodeidx,
"padding", time, 0);
355 myPadBoundaries =
false;
357 graph->
evalOpParm(myPadBoundaries, nodeidx,
"paddingboundary", time, 0);
358 myExpandPadding =
false;
360 graph->
evalOpParm(myExpandPadding, nodeidx,
"expandpadding", time, 0);
363 graph->
evalOpParm(myIterations, nodeidx,
"iterations", time, 0);
366 graph->
evalOpParm(myResolution, nodeidx,
"resolution", time, 0);
367 myCustomResolution = 1024;
368 if (
true && ( (
true&&!(((
int64(getResolution())!=5)))) ) )
369 graph->
evalOpParm(myCustomResolution, nodeidx,
"customresolution", time, 0);
370 myConnectivityTolerance = 1e-05;
372 graph->
evalOpParm(myConnectivityTolerance, nodeidx,
"uvtolerance", time, 0);
373 myScaleTolerance = 0.005;
374 if (
true && ( (
true&&!(((
int64(getScaling())==1)))) ) )
375 graph->
evalOpParm(myScaleTolerance, nodeidx,
"scaletolerance", time, 0);
377 if (
true && ( (
true&&!(((
int64(getIterations())==1)))) ) )
378 graph->
evalOpParm(myRandSeed, nodeidx,
"randseed", time, 0);
381 graph->
evalOpParm(myTargetType, nodeidx,
"targettype", time, 0);
382 myUseDefaultTarget =
false;
383 if (
true && ( (
true&&!(((
int64(getTargetType())==1)))) ) )
384 graph->
evalOpParm(myUseDefaultTarget, nodeidx,
"usedefaulttarget", time, 0);
386 if (
true && ( (
true&&!(((getUseDefaultTarget()==0))||((
int64(getTargetType())==1)))) ) )
387 graph->
evalOpParm(myDefaultTarget, nodeidx,
"defaulttarget", time, 0);
388 myUseDefaultUdimTarget =
false;
389 if (
true && ( (
true&&!(((
int64(getTargetType())!=1)))) ) )
390 graph->
evalOpParm(myUseDefaultUdimTarget, nodeidx,
"usedefaultudimtarget", time, 0);
391 myDefaultUdimTarget = 1001;
392 if (
true && ( (
true&&!(((getUseDefaultUdimTarget()==0))||((
int64(getTargetType())!=1)))) ) )
393 graph->
evalOpParm(myDefaultUdimTarget, nodeidx,
"defaultudimtarget", time, 0);
394 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) )
397 graph->
evalOpParm(length, nodeidx,
"rects", time, 0);
398 if (length < 0) length = 0;
399 myRects.setSize(length);
406 auto && _curentry = myRects(i);
408 _curentry.rect_use =
true;
409 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) && ( (
true&&!(((
int64(getTargetType())!=0)))) ) )
410 graph->
evalOpParmInst(_curentry.rect_use, nodeidx,
"rect_use#", parmidx, offsets, time, 0, 2-1);
412 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) && ( (
true&&!(((
int64(getTargetType())!=0))||((_curentry.rect_use==0)))) ) )
413 graph->
evalOpParmInst(_curentry.rect_center, nodeidx,
"rect_center#", parmidx, offsets, time, 0, 2-1);
415 if (
true && ( (!(((
int64(getTargetType())!=0))||((
int64(getTargetType())!=0)))) ) && ( (
true&&!(((
int64(getTargetType())!=0))||((_curentry.rect_use==0)))) ) )
416 graph->
evalOpParmInst(_curentry.rect_size, nodeidx,
"rect_size#", parmidx, offsets, time, 0, 2-1);
423 if (
true && ( (
true&&!(((
int64(getTargetType())!=1)))) ) )
424 graph->
evalOpParm(myTileSize, nodeidx,
"tilesize", time, 0);
426 if (
true && ( (
true&&!(((
int64(getTargetType())!=1)))) ) )
427 graph->
evalOpParm(myNumColumns, nodeidx,
"numcolumns", time, 0);
428 myStartingUdim = 1001;
429 if (
true && ( (
true&&!(((
int64(getTargetType())!=1)))) ) )
430 graph->
evalOpParm(myStartingUdim, nodeidx,
"startingudim", time, 0);
431 myTargetUVAttr =
"uv"_UTsh;
432 if (
true && ( (
true&&!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
433 graph->
evalOpParm(myTargetUVAttr, nodeidx,
"targetuvattrib", time, 0);
434 myTargetProjPlane = 0;
435 if (
true && ( (
true&&!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
436 graph->
evalOpParm(myTargetProjPlane, nodeidx,
"targetprojplane", time, 0);
437 myTargetGroup =
""_UTsh;
438 if (
true && ( (
true&&!((((graph->
getInput(nodeidx,1)>=0)==0))||((
int64(getTargetType())!=2)))) ) )
439 graph->
evalOpParm(myTargetGroup, nodeidx,
"targetgroup", time, 0);
440 myTargetSeparatorEdges =
""_UTsh;
441 if (
true && ( (
true&&!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0))||((
int64(getTargetType())!=2)))) ) )
442 graph->
evalOpParm(myTargetSeparatorEdges, nodeidx,
"targetseparatoredges", time, 0);
443 myUseTargetIslandAttr =
false;
444 if (
true && ( (
true&&!(((
int64(getTargetType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0))||((
int64(getTargetType())!=2)))) ) )
445 graph->
evalOpParm(myUseTargetIslandAttr, nodeidx,
"usetargetislandattr", time, 0);
446 myTargetIslandAttr =
"targetisland"_UTsh;
447 if (
true && ( (
true&&!(((
int64(getTargetType())!=2))||((getUseTargetIslandAttr()==0))||((
int64(getTargetType())!=2)))) ) )
448 graph->
evalOpParm(myTargetIslandAttr, nodeidx,
"targetislandattr", time, 0);
449 myStackIslands =
false;
451 graph->
evalOpParm(myStackIslands, nodeidx,
"stackislands", time, 0);
452 myStackMirrored =
false;
453 if (
true && ( (
true&&!(((getStackIslands()==0)))) ) )
454 graph->
evalOpParm(myStackMirrored, nodeidx,
"invertedoverlays", time, 0);
455 myStackOnNonGroup =
false;
456 if (
true && ( (
true&&!(((getStackIslands()==0)))) ) )
457 graph->
evalOpParm(myStackOnNonGroup, nodeidx,
"stackonnongroup", time, 0);
458 myStackingLengthTolerance = 0.02;
459 if (
true && ( (
true&&!(((getStackIslands()==0)))) ) )
460 graph->
evalOpParm(myStackingLengthTolerance, nodeidx,
"overlaytolerance", time, 0);
461 myGenerateNonpackedPolys =
false;
463 graph->
evalOpParm(myGenerateNonpackedPolys, nodeidx,
"generatenonpackedpoly", time, 0);
464 myNonpackedPolys =
"nonpacked"_UTsh;
465 if (
true && ( (
true&&!(((getGenerateNonpackedPolys()==0)))) ) )
466 graph->
evalOpParm(myNonpackedPolys, nodeidx,
"nonpackedpolys", time, 0);
467 myGenerateIslandAttr =
false;
469 graph->
evalOpParm(myGenerateIslandAttr, nodeidx,
"generateislandattr", time, 0);
470 myOutputIslandAttr =
"island"_UTsh;
471 if (
true && ( (
true&&!(((getGenerateIslandAttr()==0)))) ) )
472 graph->
evalOpParm(myOutputIslandAttr, nodeidx,
"outputislandattr", time, 0);
473 myGenerateTargetAttr =
false;
475 graph->
evalOpParm(myGenerateTargetAttr, nodeidx,
"generatetargetattr", time, 0);
476 myOutputTargetAttr =
"target"_UTsh;
477 if (
true && ( (
true&&!(((getGenerateTargetAttr()==0)))) ) )
478 graph->
evalOpParm(myOutputTargetAttr, nodeidx,
"outputtargetattr", time, 0);
494 template <
typename T>
501 if (idx.
size() != instance.
size()+1)
619 else if (instance[0] < myRects.entries())
621 auto && _data = myRects(instance[0]);
708 { doGetParmValue(idx, instance, value); }
710 { doGetParmValue(idx, instance, value); }
712 { doGetParmValue(idx, instance, value); }
714 { doGetParmValue(idx, instance, value); }
716 { doGetParmValue(idx, instance, value); }
718 { doGetParmValue(idx, instance, value); }
720 { doGetParmValue(idx, instance, value); }
722 { doGetParmValue(idx, instance, value); }
724 { doGetParmValue(idx, instance, value); }
726 { doGetParmValue(idx, instance, value); }
728 { doGetParmValue(idx, instance, value); }
730 template <
typename T>
737 if (idx.
size() != instance.
size()+1)
847 coerceValue(myUseDefaultUdimTarget, ( ( value ) ));
857 if (newsize < 0) newsize = 0;
858 myRects.setSize(newsize);
864 myRects.setSizeIfNeeded(instance[0]+1);
865 auto && _data = myRects(instance[0]);
900 coerceValue(myTargetSeparatorEdges, ( ( value ) ));
921 coerceValue(myGenerateNonpackedPolys, ( ( value ) ));
943 { doSetParmValue(idx, instance, value); }
945 { doSetParmValue(idx, instance, value); }
947 { doSetParmValue(idx, instance, value); }
949 { doSetParmValue(idx, instance, value); }
951 { doSetParmValue(idx, instance, value); }
953 { doSetParmValue(idx, instance, value); }
955 { doSetParmValue(idx, instance, value); }
957 { doSetParmValue(idx, instance, value); }
959 { doSetParmValue(idx, instance, value); }
961 { doSetParmValue(idx, instance, value); }
963 { doSetParmValue(idx, instance, value); }
981 if (fieldnum.
size() < 1)
992 return "separatoredges";
994 return "useislandattr";
998 return "usetargetattr";
1000 return "targetattr";
1002 return "targetoverrides";
1004 return "useislandscaleattr";
1006 return "islandscaleattr";
1008 return "scaleoverrides";
1010 return "useislandsetattr";
1012 return "islandoffsetattr";
1014 return "offsetoverrides";
1016 return "correctareas";
1018 return "axisalignislands";
1026 return "circledivs";
1028 return "packbetween";
1030 return "packincavities";
1034 return "paddingboundary";
1036 return "expandpadding";
1038 return "iterations";
1040 return "resolution";
1042 return "customresolution";
1044 return "uvtolerance";
1046 return "scaletolerance";
1050 return "targettype";
1052 return "usedefaulttarget";
1054 return "defaulttarget";
1056 return "usedefaultudimtarget";
1058 return "defaultudimtarget";
1060 if (fieldnum.
size() == 1)
1062 switch (fieldnum[1])
1067 return "rect_center#";
1069 return "rect_size#";
1076 return "numcolumns";
1078 return "startingudim";
1080 return "targetuvattrib";
1082 return "targetprojplane";
1084 return "targetgroup";
1086 return "targetseparatoredges";
1088 return "usetargetislandattr";
1090 return "targetislandattr";
1092 return "stackislands";
1094 return "invertedoverlays";
1096 return "stackonnongroup";
1098 return "overlaytolerance";
1100 return "generatenonpackedpoly";
1102 return "nonpackedpolys";
1104 return "generateislandattr";
1106 return "outputislandattr";
1108 return "generatetargetattr";
1110 return "outputtargetattr";
1118 if (fieldnum.
size() < 1)
1119 return PARM_UNSUPPORTED;
1120 switch (fieldnum[0])
1197 if (fieldnum.
size() == 1)
1198 return PARM_MULTIPARM;
1199 switch (fieldnum[1])
1255 { is.
bread(&v, 1); }
1269 {
for (
int r = 0;
r < 2;
r++)
for (
int c = 0; c < 2; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
1271 {
for (
int r = 0;
r < 3;
r++)
for (
int c = 0; c < 3; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
1273 {
for (
int r = 0;
r < 4;
r++)
for (
int c = 0; c < 4; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
1286 loadData(is, rampdata);
1304 int typelen = colon - data.
buffer();
1316 { UTwrite(os, &v); }
1318 {
int64 iv =
v; UTwrite(os, &iv); }
1320 { UTwrite<fpreal64>(os, &
v); }
1322 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
1324 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1325 UTwrite<fpreal64>(os, &v.
z()); }
1327 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1328 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
1340 if (s) s->save(ostr);
1341 result = ostr.
str();
1342 saveData(os, result);
1349 ostr << s->getDataTypeToken();
1351 s->saveBinary(ostr);
1353 result = ostr.
str();
1354 saveData(os, result);
1362 saveData(os, myUVAttr);
1363 saveData(os, myUVProjPlane);
1364 saveData(os, myGroup);
1365 saveData(os, mySeparatorEdges);
1366 saveData(os, myUseIslandAttr);
1367 saveData(os, myIslandAttr);
1368 saveData(os, myUseTargetAttr);
1369 saveData(os, myTargetAttr);
1370 saveData(os, myTargetOverrides);
1371 saveData(os, myUseIslandScaleAttr);
1372 saveData(os, myIslandScaleAttr);
1373 saveData(os, myScaleOverrides);
1374 saveData(os, myUseIslandOffsetAttr);
1375 saveData(os, myIslandOffsetAttr);
1376 saveData(os, myOffsetOverrides);
1377 saveData(os, myCorrectAreas);
1378 saveData(os, myAxisAlignment);
1379 saveData(os, myScaling);
1380 saveData(os, myScale);
1381 saveData(os, myRotationStep);
1382 saveData(os, myCircleDivs);
1383 saveData(os, myPackBetween);
1384 saveData(os, myPackInCavities);
1385 saveData(os, myPadding);
1386 saveData(os, myPadBoundaries);
1387 saveData(os, myExpandPadding);
1388 saveData(os, myIterations);
1389 saveData(os, myResolution);
1390 saveData(os, myCustomResolution);
1391 saveData(os, myConnectivityTolerance);
1392 saveData(os, myScaleTolerance);
1393 saveData(os, myRandSeed);
1394 saveData(os, myTargetType);
1395 saveData(os, myUseDefaultTarget);
1396 saveData(os, myDefaultTarget);
1397 saveData(os, myUseDefaultUdimTarget);
1398 saveData(os, myDefaultUdimTarget);
1401 UTwrite(os, &length);
1404 auto && _curentry = myRects(i);
1406 saveData(os, _curentry.rect_use);
1407 saveData(os, _curentry.rect_center);
1408 saveData(os, _curentry.rect_size);
1412 saveData(os, myTileSize);
1413 saveData(os, myNumColumns);
1414 saveData(os, myStartingUdim);
1415 saveData(os, myTargetUVAttr);
1416 saveData(os, myTargetProjPlane);
1417 saveData(os, myTargetGroup);
1418 saveData(os, myTargetSeparatorEdges);
1419 saveData(os, myUseTargetIslandAttr);
1420 saveData(os, myTargetIslandAttr);
1421 saveData(os, myStackIslands);
1422 saveData(os, myStackMirrored);
1423 saveData(os, myStackOnNonGroup);
1424 saveData(os, myStackingLengthTolerance);
1425 saveData(os, myGenerateNonpackedPolys);
1426 saveData(os, myNonpackedPolys);
1427 saveData(os, myGenerateIslandAttr);
1428 saveData(os, myOutputIslandAttr);
1429 saveData(os, myGenerateTargetAttr);
1430 saveData(os, myOutputTargetAttr);
1443 loadData(is, myUVAttr);
1444 loadData(is, myUVProjPlane);
1445 loadData(is, myGroup);
1446 loadData(is, mySeparatorEdges);
1447 loadData(is, myUseIslandAttr);
1448 loadData(is, myIslandAttr);
1449 loadData(is, myUseTargetAttr);
1450 loadData(is, myTargetAttr);
1451 loadData(is, myTargetOverrides);
1452 loadData(is, myUseIslandScaleAttr);
1453 loadData(is, myIslandScaleAttr);
1454 loadData(is, myScaleOverrides);
1455 loadData(is, myUseIslandOffsetAttr);
1456 loadData(is, myIslandOffsetAttr);
1457 loadData(is, myOffsetOverrides);
1458 loadData(is, myCorrectAreas);
1459 loadData(is, myAxisAlignment);
1460 loadData(is, myScaling);
1461 loadData(is, myScale);
1462 loadData(is, myRotationStep);
1463 loadData(is, myCircleDivs);
1464 loadData(is, myPackBetween);
1465 loadData(is, myPackInCavities);
1466 loadData(is, myPadding);
1467 loadData(is, myPadBoundaries);
1468 loadData(is, myExpandPadding);
1469 loadData(is, myIterations);
1470 loadData(is, myResolution);
1471 loadData(is, myCustomResolution);
1472 loadData(is, myConnectivityTolerance);
1473 loadData(is, myScaleTolerance);
1474 loadData(is, myRandSeed);
1475 loadData(is, myTargetType);
1476 loadData(is, myUseDefaultTarget);
1477 loadData(is, myDefaultTarget);
1478 loadData(is, myUseDefaultUdimTarget);
1479 loadData(is, myDefaultUdimTarget);
1482 is.
read(&length, 1);
1483 myRects.setSize(length);
1486 auto && _curentry = myRects(i);
1488 loadData(is, _curentry.rect_use);
1489 loadData(is, _curentry.rect_center);
1490 loadData(is, _curentry.rect_size);
1494 loadData(is, myTileSize);
1495 loadData(is, myNumColumns);
1496 loadData(is, myStartingUdim);
1497 loadData(is, myTargetUVAttr);
1498 loadData(is, myTargetProjPlane);
1499 loadData(is, myTargetGroup);
1500 loadData(is, myTargetSeparatorEdges);
1501 loadData(is, myUseTargetIslandAttr);
1502 loadData(is, myTargetIslandAttr);
1503 loadData(is, myStackIslands);
1504 loadData(is, myStackMirrored);
1505 loadData(is, myStackOnNonGroup);
1506 loadData(is, myStackingLengthTolerance);
1507 loadData(is, myGenerateNonpackedPolys);
1508 loadData(is, myNonpackedPolys);
1509 loadData(is, myGenerateIslandAttr);
1510 loadData(is, myOutputIslandAttr);
1511 loadData(is, myGenerateTargetAttr);
1512 loadData(is, myOutputTargetAttr);
1522 if (!thissop)
return getUVAttr();
1524 OP_Utils::evalOpParm(result, thissop,
"uvattrib", cookparms.
getCookTime(), 0);
1532 if (!thissop)
return getUVProjPlane();
1534 OP_Utils::evalOpParm(result, thissop,
"projplane", cookparms.
getCookTime(), 0);
1542 if (!thissop)
return getGroup();
1544 OP_Utils::evalOpParm(result, thissop,
"group", cookparms.
getCookTime(), 0);
1552 if (!thissop)
return getSeparatorEdges();
1554 OP_Utils::evalOpParm(result, thissop,
"separatoredges", cookparms.
getCookTime(), 0);
1562 if (!thissop)
return getUseIslandAttr();
1564 OP_Utils::evalOpParm(result, thissop,
"useislandattr", cookparms.
getCookTime(), 0);
1572 if (!thissop)
return getIslandAttr();
1574 OP_Utils::evalOpParm(result, thissop,
"islandattr", cookparms.
getCookTime(), 0);
1582 if (!thissop)
return getUseTargetAttr();
1584 OP_Utils::evalOpParm(result, thissop,
"usetargetattr", cookparms.
getCookTime(), 0);
1592 if (!thissop)
return getTargetAttr();
1594 OP_Utils::evalOpParm(result, thissop,
"targetattr", cookparms.
getCookTime(), 0);
1602 if (!thissop)
return getTargetOverrides();
1604 OP_Utils::evalOpParm(result, thissop,
"targetoverrides", cookparms.
getCookTime(), 0);
1612 if (!thissop)
return getUseIslandScaleAttr();
1614 OP_Utils::evalOpParm(result, thissop,
"useislandscaleattr", cookparms.
getCookTime(), 0);
1622 if (!thissop)
return getIslandScaleAttr();
1624 OP_Utils::evalOpParm(result, thissop,
"islandscaleattr", cookparms.
getCookTime(), 0);
1632 if (!thissop)
return getScaleOverrides();
1634 OP_Utils::evalOpParm(result, thissop,
"scaleoverrides", cookparms.
getCookTime(), 0);
1642 if (!thissop)
return getUseIslandOffsetAttr();
1644 OP_Utils::evalOpParm(result, thissop,
"useislandsetattr", cookparms.
getCookTime(), 0);
1652 if (!thissop)
return getIslandOffsetAttr();
1654 OP_Utils::evalOpParm(result, thissop,
"islandoffsetattr", cookparms.
getCookTime(), 0);
1662 if (!thissop)
return getOffsetOverrides();
1664 OP_Utils::evalOpParm(result, thissop,
"offsetoverrides", cookparms.
getCookTime(), 0);
1672 if (!thissop)
return getCorrectAreas();
1674 OP_Utils::evalOpParm(result, thissop,
"correctareas", cookparms.
getCookTime(), 0);
1682 if (!thissop)
return getAxisAlignment();
1684 OP_Utils::evalOpParm(result, thissop,
"axisalignislands", cookparms.
getCookTime(), 0);
1692 if (!thissop)
return getScaling();
1694 OP_Utils::evalOpParm(result, thissop,
"scaling", cookparms.
getCookTime(), 0);
1704 OP_Utils::evalOpParm(result, thissop,
"scale", cookparms.
getCookTime(), 0);
1712 if (!thissop)
return getRotationStep();
1714 OP_Utils::evalOpParm(result, thissop,
"rotstep", cookparms.
getCookTime(), 0);
1722 if (!thissop)
return getCircleDivs();
1724 OP_Utils::evalOpParm(result, thissop,
"circledivs", cookparms.
getCookTime(), 0);
1732 if (!thissop)
return getPackBetween();
1734 OP_Utils::evalOpParm(result, thissop,
"packbetween", cookparms.
getCookTime(), 0);
1742 if (!thissop)
return getPackInCavities();
1744 OP_Utils::evalOpParm(result, thissop,
"packincavities", cookparms.
getCookTime(), 0);
1752 if (!thissop)
return getPadding();
1754 OP_Utils::evalOpParm(result, thissop,
"padding", cookparms.
getCookTime(), 0);
1762 if (!thissop)
return getPadBoundaries();
1764 OP_Utils::evalOpParm(result, thissop,
"paddingboundary", cookparms.
getCookTime(), 0);
1772 if (!thissop)
return getExpandPadding();
1774 OP_Utils::evalOpParm(result, thissop,
"expandpadding", cookparms.
getCookTime(), 0);
1782 if (!thissop)
return getIterations();
1784 OP_Utils::evalOpParm(result, thissop,
"iterations", cookparms.
getCookTime(), 0);
1792 if (!thissop)
return getResolution();
1794 OP_Utils::evalOpParm(result, thissop,
"resolution", cookparms.
getCookTime(), 0);
1802 if (!thissop)
return getCustomResolution();
1804 OP_Utils::evalOpParm(result, thissop,
"customresolution", cookparms.
getCookTime(), 0);
1812 if (!thissop)
return getConnectivityTolerance();
1814 OP_Utils::evalOpParm(result, thissop,
"uvtolerance", cookparms.
getCookTime(), 0);
1822 if (!thissop)
return getScaleTolerance();
1824 OP_Utils::evalOpParm(result, thissop,
"scaletolerance", cookparms.
getCookTime(), 0);
1832 if (!thissop)
return getRandSeed();
1834 OP_Utils::evalOpParm(result, thissop,
"randseed", cookparms.
getCookTime(), 0);
1842 if (!thissop)
return getTargetType();
1844 OP_Utils::evalOpParm(result, thissop,
"targettype", cookparms.
getCookTime(), 0);
1852 if (!thissop)
return getUseDefaultTarget();
1854 OP_Utils::evalOpParm(result, thissop,
"usedefaulttarget", cookparms.
getCookTime(), 0);
1862 if (!thissop)
return getDefaultTarget();
1864 OP_Utils::evalOpParm(result, thissop,
"defaulttarget", cookparms.
getCookTime(), 0);
1872 if (!thissop)
return getUseDefaultUdimTarget();
1874 OP_Utils::evalOpParm(result, thissop,
"usedefaultudimtarget", cookparms.
getCookTime(), 0);
1882 if (!thissop)
return getDefaultUdimTarget();
1884 OP_Utils::evalOpParm(result, thissop,
"defaultudimtarget", cookparms.
getCookTime(), 0);
1892 if (!thissop)
return getRects().entries();
1894 OP_Utils::evalOpParm(result, thissop,
"rects", cookparms.
getCookTime(), 0);
1898 {
return opinstRects_rect_use(cookparms, &_idx); }
1902 if (!thissop)
return (myRects(_idx[0]).rect_use);
1904 _parmidx[1-1] = _idx[1-1] + 0;
1907 OP_Utils::evalOpParmInst(result, thissop,
"rect_use#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
1911 {
return opinstRects_rect_center(cookparms, &_idx); }
1915 if (!thissop)
return (myRects(_idx[0]).rect_center);
1917 _parmidx[1-1] = _idx[1-1] + 0;
1920 OP_Utils::evalOpParmInst(result, thissop,
"rect_center#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
1924 {
return opinstRects_rect_size(cookparms, &_idx); }
1928 if (!thissop)
return (myRects(_idx[0]).rect_size);
1930 _parmidx[1-1] = _idx[1-1] + 0;
1933 OP_Utils::evalOpParmInst(result, thissop,
"rect_size#", _parmidx, cookparms.
getCookTime(), 0, 2-1);
1942 if (!thissop)
return getTileSize();
1944 OP_Utils::evalOpParm(result, thissop,
"tilesize", cookparms.
getCookTime(), 0);
1952 if (!thissop)
return getNumColumns();
1954 OP_Utils::evalOpParm(result, thissop,
"numcolumns", cookparms.
getCookTime(), 0);
1962 if (!thissop)
return getStartingUdim();
1964 OP_Utils::evalOpParm(result, thissop,
"startingudim", cookparms.
getCookTime(), 0);
1972 if (!thissop)
return getTargetUVAttr();
1974 OP_Utils::evalOpParm(result, thissop,
"targetuvattrib", cookparms.
getCookTime(), 0);
1982 if (!thissop)
return getTargetProjPlane();
1984 OP_Utils::evalOpParm(result, thissop,
"targetprojplane", cookparms.
getCookTime(), 0);
1992 if (!thissop)
return getTargetGroup();
1994 OP_Utils::evalOpParm(result, thissop,
"targetgroup", cookparms.
getCookTime(), 0);
2002 if (!thissop)
return getTargetSeparatorEdges();
2004 OP_Utils::evalOpParm(result, thissop,
"targetseparatoredges", cookparms.
getCookTime(), 0);
2012 if (!thissop)
return getUseTargetIslandAttr();
2014 OP_Utils::evalOpParm(result, thissop,
"usetargetislandattr", cookparms.
getCookTime(), 0);
2022 if (!thissop)
return getTargetIslandAttr();
2024 OP_Utils::evalOpParm(result, thissop,
"targetislandattr", cookparms.
getCookTime(), 0);
2032 if (!thissop)
return getStackIslands();
2034 OP_Utils::evalOpParm(result, thissop,
"stackislands", cookparms.
getCookTime(), 0);
2042 if (!thissop)
return getStackMirrored();
2044 OP_Utils::evalOpParm(result, thissop,
"invertedoverlays", cookparms.
getCookTime(), 0);
2052 if (!thissop)
return getStackOnNonGroup();
2054 OP_Utils::evalOpParm(result, thissop,
"stackonnongroup", cookparms.
getCookTime(), 0);
2062 if (!thissop)
return getStackingLengthTolerance();
2064 OP_Utils::evalOpParm(result, thissop,
"overlaytolerance", cookparms.
getCookTime(), 0);
2072 if (!thissop)
return getGenerateNonpackedPolys();
2074 OP_Utils::evalOpParm(result, thissop,
"generatenonpackedpoly", cookparms.
getCookTime(), 0);
2082 if (!thissop)
return getNonpackedPolys();
2084 OP_Utils::evalOpParm(result, thissop,
"nonpackedpolys", cookparms.
getCookTime(), 0);
2092 if (!thissop)
return getGenerateIslandAttr();
2094 OP_Utils::evalOpParm(result, thissop,
"generateislandattr", cookparms.
getCookTime(), 0);
2102 if (!thissop)
return getOutputIslandAttr();
2104 OP_Utils::evalOpParm(result, thissop,
"outputislandattr", cookparms.
getCookTime(), 0);
2112 if (!thissop)
return getGenerateTargetAttr();
2114 OP_Utils::evalOpParm(result, thissop,
"generatetargetattr", cookparms.
getCookTime(), 0);
2122 if (!thissop)
return getOutputTargetAttr();
2124 OP_Utils::evalOpParm(result, thissop,
"outputtargetattr", cookparms.
getCookTime(), 0);
2130 int64 myUVProjPlane;
2133 bool myUseIslandAttr;
2135 bool myUseTargetAttr;
2138 bool myUseIslandScaleAttr;
2141 bool myUseIslandOffsetAttr;
2144 bool myCorrectAreas;
2145 int64 myAxisAlignment;
2148 int64 myRotationStep;
2151 bool myPackInCavities;
2153 bool myPadBoundaries;
2154 bool myExpandPadding;
2157 int64 myCustomResolution;
2162 bool myUseDefaultTarget;
2163 int64 myDefaultTarget;
2164 bool myUseDefaultUdimTarget;
2165 int64 myDefaultUdimTarget;
2169 int64 myStartingUdim;
2171 int64 myTargetProjPlane;
2174 bool myUseTargetIslandAttr;
2176 bool myStackIslands;
2177 bool myStackMirrored;
2178 bool myStackOnNonGroup;
2179 fpreal64 myStackingLengthTolerance;
2180 bool myGenerateNonpackedPolys;
2182 bool myGenerateIslandAttr;
2184 bool myGenerateTargetAttr;
void setIslandScaleAttr(const UT_StringHolder &val)
bool opRects_rect_use(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
void setStackOnNonGroup(bool val)
TargetType getTargetType() const
bool getCorrectAreas() const
void loadFromOpSubclass(const LoadParms &loadparms) override
UT_Vector2D opRects_rect_size(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
void setUVProjPlane(UVProjPlane val)
void setPackBetween(bool val)
fpreal64 getScale() const
GLenum GLuint GLenum GLsizei const GLchar * buf
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
T clampMaxValue(fpreal maxvalue, const T &src) const
void setStartingUdim(int64 val)
UT_Vector2D opinstRects_rect_size(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
constexpr SYS_FORCE_INLINE T & y() noexcept
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)
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
const OP_Context & context() const
void setScaling(Scaling val)
bool opPadBoundaries(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & z() noexcept
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
GLuint GLsizei GLsizei * length
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)
UT_Vector2D opinstRects_rect_center(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
void setNumColumns(int64 val)
UT_Vector2D getTileSize() const
const char * getNestParmName(TempIndex fieldnum) const override
**But if you need a result
int64 getIterations() const
static void loadData(UT_IStream &is, UT_Vector2I &v)
T clampMinValue(fpreal minvalue, const T &src) const
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 opinstRects_rect_use(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
bool getUseDefaultTarget() const
void setGenerateNonpackedPolys(bool val)
void setPadding(int64 val)
virtual NodeIdx getInput(NodeIdx idx, int input, bool markused=false) const =0
bool opStackIslands(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & x() noexcept
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
GLuint GLsizei const GLuint const GLintptr * offsets
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
bool getGenerateNonpackedPolys() const
constexpr SYS_FORCE_INLINE T & x() noexcept
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)
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
constexpr SYS_FORCE_INLINE T & z() noexcept
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
bool load(UT_IStream &is)
static void saveData(std::ostream &os, UT_Vector2D v)
UT_Vector2D opRects_rect_center(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
void setUseIslandScaleAttr(bool val)
exint read(bool *array, exint sz=1)
const OP_GraphProxy * graph() const
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)
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)
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
int64 getNumColumns() const
UT_StringHolder opIslandOffsetAttr(const SOP_NodeVerb::CookParms &cookparms) const
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
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
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
const UT_StringHolder & getOffsetOverrides() const
UT_StringHolder opOutputIslandAttr(const SOP_NodeVerb::CookParms &cookparms) const
TargetProjPlane getTargetProjPlane() const
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
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
void coerceValue(T &result, const S &src) 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 copyFrom(const OP_NodeParms *src) override
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
DEP_MicroNode * depnode() 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
bool isParmColorRamp(exint idx) const override
static void loadData(UT_IStream &is, UT_Vector3D &v)
constexpr SYS_FORCE_INLINE T & w() noexcept
SYS_FORCE_INLINE void append(char character)
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
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
constexpr SYS_FORCE_INLINE T & y() noexcept
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
TargetProjPlane opTargetProjPlane(const SOP_NodeVerb::CookParms &cookparms) const
bool getExpandPadding() const
void setTargetIslandAttr(const UT_StringHolder &val)
const UT_StringHolder & getTargetAttr() const
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
constexpr SYS_FORCE_INLINE T & y() noexcept
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
OP_NodeParms & operator=(const OP_NodeParms &)=default
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)
constexpr SYS_FORCE_INLINE T & x() noexcept
void setTargetGroup(const UT_StringHolder &val)