23 namespace SOP_PolyExtrude_2_0Enums
122 myUseSplitGroup =
false;
123 mySplitGroup =
""_UTsh;
126 myPtNormalAttrib =
"N"_UTsh;
132 myXformFront =
false;
143 myPreXformRotateOrder = 0;
148 myOutputFront =
true;
149 myOutputFrontGrp =
false;
150 myFrontGrp =
"extrudeFront"_UTsh;
151 myOutputBack =
false;
152 myOutputBackGrp =
false;
153 myBackGrp =
"extrudeBack"_UTsh;
155 myOutputSideGrp =
false;
156 mySideGrp =
"extrudeSide"_UTsh;
157 myOutputFrontSeamGrp =
false;
158 myFrontSeamGrp =
"extrudeFrontSeam"_UTsh;
159 myOutputBackSeamGrp =
false;
160 myBackSeamGrp =
"extrudeBackSeam"_UTsh;
161 myPreserveGroups =
true;
163 myCommonLimit =
true;
164 myAddVertexNormals =
false;
171 myFrontMagnitude = 1;
173 myFrontStiffness = 0;
177 myReverseSpineDirection =
false;
181 myThicknessScale = 1;
182 myUseThicknessAttrib =
true;
183 myThicknessAttrib =
"thickness"_UTsh;
184 myUseThicknessRamp =
true;
186 myUseTwistAttrib =
true;
187 myTwistAttrib =
"twist"_UTsh;
188 myUseTwistRamp =
true;
191 myUseLocalZScaleAttrib =
false;
192 myLocalZScaleAttrib =
"zscale"_UTsh;
193 myUseLocalInsetScaleAttrib =
false;
194 myLocalInsetScaleAttrib =
"insetscale"_UTsh;
195 myUseLocalTwistScaleAttrib =
false;
196 myLocalTwistScaleAttrib =
"twistscale"_UTsh;
197 myUseLocalDivScaleAttrib =
false;
198 myLocalDivScaleAttrib =
"divsscale"_UTsh;
199 myUseLocalXAttrib =
false;
200 myLocalXAttrib =
"localx"_UTsh;
201 myUseLocalZAttrib =
false;
202 myLocalZAttrib =
"localz"_UTsh;
203 myUseLocalCtrAttrib =
false;
204 myLocalCtrAttrib =
"localctr"_UTsh;
217 if (myGroup != src.myGroup)
return false;
218 if (mySplitType != src.mySplitType)
return false;
219 if (myUseSplitGroup != src.myUseSplitGroup)
return false;
220 if (mySplitGroup != src.mySplitGroup)
return false;
221 if (myExtrusionMode != src.myExtrusionMode)
return false;
222 if (myPtNormalSrc != src.myPtNormalSrc)
return false;
223 if (myPtNormalAttrib != src.myPtNormalAttrib)
return false;
224 if (myDist != src.myDist)
return false;
225 if (myInset != src.myInset)
return false;
226 if (myTwist != src.myTwist)
return false;
227 if (myDivs != src.myDivs)
return false;
228 if (mySpineType != src.mySpineType)
return false;
229 if (myXformFront != src.myXformFront)
return false;
230 if (myXformSpace != src.myXformSpace)
return false;
231 if (myXformOrder != src.myXformOrder)
return false;
232 if (myRotateOrder != src.myRotateOrder)
return false;
233 if (myTranslate != src.myTranslate)
return false;
234 if (myRotate != src.myRotate)
return false;
235 if (myScale != src.myScale)
return false;
236 if (myShear != src.myShear)
return false;
237 if (myPivot != src.myPivot)
return false;
238 if (myPivotRotate != src.myPivotRotate)
return false;
239 if (myPreXformOrder != src.myPreXformOrder)
return false;
240 if (myPreXformRotateOrder != src.myPreXformRotateOrder)
return false;
241 if (myPreXformTranslate != src.myPreXformTranslate)
return false;
242 if (myPreXformRotate != src.myPreXformRotate)
return false;
243 if (myPreXformScale != src.myPreXformScale)
return false;
244 if (myPreXformShear != src.myPreXformShear)
return false;
245 if (myOutputFront != src.myOutputFront)
return false;
246 if (myOutputFrontGrp != src.myOutputFrontGrp)
return false;
247 if (myFrontGrp != src.myFrontGrp)
return false;
248 if (myOutputBack != src.myOutputBack)
return false;
249 if (myOutputBackGrp != src.myOutputBackGrp)
return false;
250 if (myBackGrp != src.myBackGrp)
return false;
251 if (myOutputSide != src.myOutputSide)
return false;
252 if (myOutputSideGrp != src.myOutputSideGrp)
return false;
253 if (mySideGrp != src.mySideGrp)
return false;
254 if (myOutputFrontSeamGrp != src.myOutputFrontSeamGrp)
return false;
255 if (myFrontSeamGrp != src.myFrontSeamGrp)
return false;
256 if (myOutputBackSeamGrp != src.myOutputBackSeamGrp)
return false;
257 if (myBackSeamGrp != src.myBackSeamGrp)
return false;
258 if (myPreserveGroups != src.myPreserveGroups)
return false;
259 if (myLimitInset != src.myLimitInset)
return false;
260 if (myCommonLimit != src.myCommonLimit)
return false;
261 if (myAddVertexNormals != src.myAddVertexNormals)
return false;
262 if (myCuspAngle != src.myCuspAngle)
return false;
263 if (myCuspFront != src.myCuspFront)
return false;
264 if (myCuspBack != src.myCuspBack)
return false;
265 if (myGenUVs != src.myGenUVs)
return false;
266 if (myUVStyle != src.myUVStyle)
return false;
267 if (myUVScaling != src.myUVScaling)
return false;
268 if (myFrontMagnitude != src.myFrontMagnitude)
return false;
269 if (myBackMagnitude != src.myBackMagnitude)
return false;
270 if (myFrontStiffness != src.myFrontStiffness)
return false;
271 if (myBackStiffness != src.myBackStiffness)
return false;
272 if (myInterpolation != src.myInterpolation)
return false;
273 if (mySpacing != src.mySpacing)
return false;
274 if (myReverseSpineDirection != src.myReverseSpineDirection)
return false;
275 if (myAxialRotation != src.myAxialRotation)
return false;
276 if (myFrontBlend != src.myFrontBlend)
return false;
277 if (myBackBlend != src.myBackBlend)
return false;
278 if (myThicknessScale != src.myThicknessScale)
return false;
279 if (myUseThicknessAttrib != src.myUseThicknessAttrib)
return false;
280 if (myThicknessAttrib != src.myThicknessAttrib)
return false;
281 if (myUseThicknessRamp != src.myUseThicknessRamp)
return false;
282 if (myThicknessRamp != src.myThicknessRamp)
283 {
if (!myThicknessRamp || !src.myThicknessRamp || !(*myThicknessRamp == *src.myThicknessRamp))
return false; }
284 if (myUseTwistAttrib != src.myUseTwistAttrib)
return false;
285 if (myTwistAttrib != src.myTwistAttrib)
return false;
286 if (myUseTwistRamp != src.myUseTwistRamp)
return false;
287 if (myTwistRamp != src.myTwistRamp)
288 {
if (!myTwistRamp || !src.myTwistRamp || !(*myTwistRamp == *src.myTwistRamp))
return false; }
289 if (myTwistScale != src.myTwistScale)
return false;
290 if (myUseLocalZScaleAttrib != src.myUseLocalZScaleAttrib)
return false;
291 if (myLocalZScaleAttrib != src.myLocalZScaleAttrib)
return false;
292 if (myUseLocalInsetScaleAttrib != src.myUseLocalInsetScaleAttrib)
return false;
293 if (myLocalInsetScaleAttrib != src.myLocalInsetScaleAttrib)
return false;
294 if (myUseLocalTwistScaleAttrib != src.myUseLocalTwistScaleAttrib)
return false;
295 if (myLocalTwistScaleAttrib != src.myLocalTwistScaleAttrib)
return false;
296 if (myUseLocalDivScaleAttrib != src.myUseLocalDivScaleAttrib)
return false;
297 if (myLocalDivScaleAttrib != src.myLocalDivScaleAttrib)
return false;
298 if (myUseLocalXAttrib != src.myUseLocalXAttrib)
return false;
299 if (myLocalXAttrib != src.myLocalXAttrib)
return false;
300 if (myUseLocalZAttrib != src.myUseLocalZAttrib)
return false;
301 if (myLocalZAttrib != src.myLocalZAttrib)
return false;
302 if (myUseLocalCtrAttrib != src.myUseLocalCtrAttrib)
return false;
303 if (myLocalCtrAttrib != src.myLocalCtrAttrib)
return false;
331 graph->
evalOpParm(myGroup, nodeidx,
"group", time, 0);
334 graph->
evalOpParm(mySplitType, nodeidx,
"splittype", time, 0);
335 myUseSplitGroup =
false;
336 if (
true && ( (
true&&!(((
int64(getSplitType())!=1)))) ) )
337 graph->
evalOpParm(myUseSplitGroup, nodeidx,
"usesplitgroup", time, 0);
338 mySplitGroup =
""_UTsh;
339 if (
true && ( (
true&&!(((
int64(getSplitType())!=1))||((getUseSplitGroup()!=1)))) ) )
340 graph->
evalOpParm(mySplitGroup, nodeidx,
"splitgroup", time, 0);
343 graph->
evalOpParm(myExtrusionMode, nodeidx,
"extrusionmode", time, 0);
345 if (
true && ( (
true&&!(((
int64(getExtrusionMode())!=1)))) ) )
346 graph->
evalOpParm(myPtNormalSrc, nodeidx,
"ptnormalsrc", time, 0);
347 myPtNormalAttrib =
"N"_UTsh;
348 if (
true && ( (
true&&!(((
int64(getExtrusionMode())!=1))||((
int64(getPtNormalSrc())!=2)))) ) )
349 graph->
evalOpParm(myPtNormalAttrib, nodeidx,
"ptnormalattrib", time, 0);
352 graph->
evalOpParm(myDist, nodeidx,
"dist", time, 0);
355 graph->
evalOpParm(myInset, nodeidx,
"inset", time, 0);
358 graph->
evalOpParm(myTwist, nodeidx,
"twist", time, 0);
361 graph->
evalOpParm(myDivs, nodeidx,
"divs", time, 0);
364 graph->
evalOpParm(mySpineType, nodeidx,
"spinetype", time, 0);
365 myXformFront =
false;
367 graph->
evalOpParm(myXformFront, nodeidx,
"xformfront", time, 0);
369 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
370 graph->
evalOpParm(myXformSpace, nodeidx,
"xformspace", time, 0);
372 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
373 graph->
evalOpParm(myXformOrder, nodeidx,
"rst", time, 0);
375 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
376 graph->
evalOpParm(myRotateOrder, nodeidx,
"xyz", time, 0);
378 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
379 graph->
evalOpParm(myTranslate, nodeidx,
"translate", time, 0);
381 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
382 graph->
evalOpParm(myRotate, nodeidx,
"rotate", time, 0);
384 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
385 graph->
evalOpParm(myScale, nodeidx,
"scale", time, 0);
387 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
388 graph->
evalOpParm(myShear, nodeidx,
"shear", time, 0);
390 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
391 graph->
evalOpParm(myPivot, nodeidx,
"pivot", time, 0);
393 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
394 graph->
evalOpParm(myPivotRotate, nodeidx,
"pivotrotate", time, 0);
396 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
397 graph->
evalOpParm(myPreXformOrder, nodeidx,
"prexform_rst", time, 0);
398 myPreXformRotateOrder = 0;
399 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
400 graph->
evalOpParm(myPreXformRotateOrder, nodeidx,
"prexform_xyz", time, 0);
402 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
403 graph->
evalOpParm(myPreXformTranslate, nodeidx,
"prexform_translate", time, 0);
405 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
406 graph->
evalOpParm(myPreXformRotate, nodeidx,
"prexform_rotate", time, 0);
408 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
409 graph->
evalOpParm(myPreXformScale, nodeidx,
"prexform_scale", time, 0);
411 if (
true && ( (
true&&!(((getXformFront()==0)))) ) )
412 graph->
evalOpParm(myPreXformShear, nodeidx,
"prexform_shear", time, 0);
413 myOutputFront =
true;
415 graph->
evalOpParm(myOutputFront, nodeidx,
"outputfront", time, 0);
416 myOutputFrontGrp =
false;
418 graph->
evalOpParm(myOutputFrontGrp, nodeidx,
"outputfrontgrp", time, 0);
419 myFrontGrp =
"extrudeFront"_UTsh;
420 if (
true && ( (
true&&!(((getOutputFrontGrp()==0)))) ) )
421 graph->
evalOpParm(myFrontGrp, nodeidx,
"frontgrp", time, 0);
422 myOutputBack =
false;
424 graph->
evalOpParm(myOutputBack, nodeidx,
"outputback", time, 0);
425 myOutputBackGrp =
false;
427 graph->
evalOpParm(myOutputBackGrp, nodeidx,
"outputbackgrp", time, 0);
428 myBackGrp =
"extrudeBack"_UTsh;
429 if (
true && ( (
true&&!(((getOutputBackGrp()==0)))) ) )
430 graph->
evalOpParm(myBackGrp, nodeidx,
"backgrp", time, 0);
433 graph->
evalOpParm(myOutputSide, nodeidx,
"outputside", time, 0);
434 myOutputSideGrp =
false;
436 graph->
evalOpParm(myOutputSideGrp, nodeidx,
"outputsidegrp", time, 0);
437 mySideGrp =
"extrudeSide"_UTsh;
438 if (
true && ( (
true&&!(((getOutputSideGrp()==0)))) ) )
439 graph->
evalOpParm(mySideGrp, nodeidx,
"sidegrp", time, 0);
440 myOutputFrontSeamGrp =
false;
442 graph->
evalOpParm(myOutputFrontSeamGrp, nodeidx,
"outputfrontseamgrp", time, 0);
443 myFrontSeamGrp =
"extrudeFrontSeam"_UTsh;
444 if (
true && ( (
true&&!(((getOutputFrontSeamGrp()==0)))) ) )
445 graph->
evalOpParm(myFrontSeamGrp, nodeidx,
"frontseamgrp", time, 0);
446 myOutputBackSeamGrp =
false;
448 graph->
evalOpParm(myOutputBackSeamGrp, nodeidx,
"outputbackseamgrp", time, 0);
449 myBackSeamGrp =
"extrudeBackSeam"_UTsh;
450 if (
true && ( (
true&&!(((getOutputBackSeamGrp()==0)))) ) )
451 graph->
evalOpParm(myBackSeamGrp, nodeidx,
"backseamgrp", time, 0);
452 myPreserveGroups =
true;
454 graph->
evalOpParm(myPreserveGroups, nodeidx,
"preservegroups", time, 0);
457 graph->
evalOpParm(myLimitInset, nodeidx,
"limitinset", time, 0);
458 myCommonLimit =
true;
459 if (
true && ( (
true&&!(((getLimitInset()==0)))) ) )
460 graph->
evalOpParm(myCommonLimit, nodeidx,
"commonlimit", time, 0);
461 myAddVertexNormals =
false;
463 graph->
evalOpParm(myAddVertexNormals, nodeidx,
"addvertexnomrals", time, 0);
465 if (
true && ( (
true&&!(((getAddVertexNormals()==0)))) ) )
466 graph->
evalOpParm(myCuspAngle, nodeidx,
"cuspangle", time, 0);
468 if (
true && ( (
true&&!(((getAddVertexNormals()==0)))) ) )
469 graph->
evalOpParm(myCuspFront, nodeidx,
"cuspfront", time, 0);
471 if (
true && ( (
true&&!(((getAddVertexNormals()==0)))) ) )
472 graph->
evalOpParm(myCuspBack, nodeidx,
"cuspback", time, 0);
475 graph->
evalOpParm(myGenUVs, nodeidx,
"genuvs", time, 0);
477 if (
true && ( (
true&&!(((getGenUVs()==0)))) ) )
478 graph->
evalOpParm(myUVStyle, nodeidx,
"uvstyle", time, 0);
480 if (
true && ( (
true&&!(((getGenUVs()==0)))) ) )
481 graph->
evalOpParm(myUVScaling, nodeidx,
"uvscaling", time, 0);
482 myFrontMagnitude = 1;
483 if (
true && ( (
true&&!(((
int64(getSpineType())==0)))) ) )
484 graph->
evalOpParm(myFrontMagnitude, nodeidx,
"frontmagnitude", time, 0);
486 if (
true && ( (
true&&!(((
int64(getSpineType())==0)))) ) )
487 graph->
evalOpParm(myBackMagnitude, nodeidx,
"backmagnitude", time, 0);
488 myFrontStiffness = 0;
489 if (
true && ( (
true&&!(((
int64(getSpineType())==0)))) ) )
490 graph->
evalOpParm(myFrontStiffness, nodeidx,
"frontstiffness", time, 0);
492 if (
true && ( (
true&&!(((
int64(getSpineType())==0)))) ) )
493 graph->
evalOpParm(myBackStiffness, nodeidx,
"backstiffness", time, 0);
496 graph->
evalOpParm(myInterpolation, nodeidx,
"interpolation", time, 0);
499 graph->
evalOpParm(mySpacing, nodeidx,
"spacing", time, 0);
500 myReverseSpineDirection =
false;
501 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
502 graph->
evalOpParm(myReverseSpineDirection, nodeidx,
"reversespinedirection", time, 0);
504 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
505 graph->
evalOpParm(myAxialRotation, nodeidx,
"axialrotation", time, 0);
507 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
508 graph->
evalOpParm(myFrontBlend, nodeidx,
"frontblend", time, 0);
510 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
511 graph->
evalOpParm(myBackBlend, nodeidx,
"backblend", time, 0);
512 myThicknessScale = 1;
514 graph->
evalOpParm(myThicknessScale, nodeidx,
"thicknessscale", time, 0);
515 myUseThicknessAttrib =
true;
516 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
517 graph->
evalOpParm(myUseThicknessAttrib, nodeidx,
"usethicknessattrib", time, 0);
518 myThicknessAttrib =
"thickness"_UTsh;
519 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0))||((getUseThicknessAttrib()==0)))) ) )
520 graph->
evalOpParm(myThicknessAttrib, nodeidx,
"thicknessattrib", time, 0);
521 myUseThicknessRamp =
true;
523 graph->
evalOpParm(myUseThicknessRamp, nodeidx,
"usethicknessramp", time, 0);
525 if (
true && ( (
true&&!(((getUseThicknessRamp()==0)))) ) )
526 graph->
evalOpParm(myThicknessRamp, nodeidx,
"thicknessramp", time, 0);
527 myUseTwistAttrib =
true;
528 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0)))) ) )
529 graph->
evalOpParm(myUseTwistAttrib, nodeidx,
"usetwistattrib", time, 0);
530 myTwistAttrib =
"twist"_UTsh;
531 if (
true && ( (
true&&!(((
int64(getSpineType())!=2))||(((graph->
getInput(nodeidx,1)>=0)==0))||((getUseTwistAttrib()==0)))) ) )
532 graph->
evalOpParm(myTwistAttrib, nodeidx,
"twistattrib", time, 0);
533 myUseTwistRamp =
true;
535 graph->
evalOpParm(myUseTwistRamp, nodeidx,
"usetwistramp", time, 0);
537 if (
true && ( (
true&&!(((getUseTwistRamp()==0)))) ) )
538 graph->
evalOpParm(myTwistRamp, nodeidx,
"twistramp", time, 0);
541 graph->
evalOpParm(myTwistScale, nodeidx,
"twistscale", time, 0);
542 myUseLocalZScaleAttrib =
false;
544 graph->
evalOpParm(myUseLocalZScaleAttrib, nodeidx,
"uselocalzscaleattrib", time, 0);
545 myLocalZScaleAttrib =
"zscale"_UTsh;
546 if (
true && ( (
true&&!(((getUseLocalZScaleAttrib()==0)))) ) )
547 graph->
evalOpParm(myLocalZScaleAttrib, nodeidx,
"localzscaleattrib", time, 0);
548 myUseLocalInsetScaleAttrib =
false;
550 graph->
evalOpParm(myUseLocalInsetScaleAttrib, nodeidx,
"uselocalinsetscaleattrib", time, 0);
551 myLocalInsetScaleAttrib =
"insetscale"_UTsh;
552 if (
true && ( (
true&&!(((getUseLocalInsetScaleAttrib()==0)))) ) )
553 graph->
evalOpParm(myLocalInsetScaleAttrib, nodeidx,
"localinsetscaleattrib", time, 0);
554 myUseLocalTwistScaleAttrib =
false;
556 graph->
evalOpParm(myUseLocalTwistScaleAttrib, nodeidx,
"uselocaltwistattrib", time, 0);
557 myLocalTwistScaleAttrib =
"twistscale"_UTsh;
558 if (
true && ( (
true&&!(((getUseLocalTwistScaleAttrib()==0)))) ) )
559 graph->
evalOpParm(myLocalTwistScaleAttrib, nodeidx,
"localtwistscaleattrib", time, 0);
560 myUseLocalDivScaleAttrib =
false;
562 graph->
evalOpParm(myUseLocalDivScaleAttrib, nodeidx,
"uselocaldivsattrib", time, 0);
563 myLocalDivScaleAttrib =
"divsscale"_UTsh;
564 if (
true && ( (
true&&!(((getUseLocalDivScaleAttrib()==0)))) ) )
565 graph->
evalOpParm(myLocalDivScaleAttrib, nodeidx,
"locadivscaleattrib", time, 0);
566 myUseLocalXAttrib =
false;
568 graph->
evalOpParm(myUseLocalXAttrib, nodeidx,
"uselocalxattrib", time, 0);
569 myLocalXAttrib =
"localx"_UTsh;
570 if (
true && ( (
true&&!(((getUseLocalXAttrib()==0)))) ) )
571 graph->
evalOpParm(myLocalXAttrib, nodeidx,
"localxattrib", time, 0);
572 myUseLocalZAttrib =
false;
574 graph->
evalOpParm(myUseLocalZAttrib, nodeidx,
"uselocalzattirb", time, 0);
575 myLocalZAttrib =
"localz"_UTsh;
576 if (
true && ( (
true&&!(((getUseLocalZAttrib()==0)))) ) )
577 graph->
evalOpParm(myLocalZAttrib, nodeidx,
"localzattirb", time, 0);
578 myUseLocalCtrAttrib =
false;
580 graph->
evalOpParm(myUseLocalCtrAttrib, nodeidx,
"uselocalctrattrib", time, 0);
581 myLocalCtrAttrib =
"localctr"_UTsh;
582 if (
true && ( (
true&&!(((getUseLocalCtrAttrib()==0)))) ) )
583 graph->
evalOpParm(myLocalCtrAttrib, nodeidx,
"localctrattrib", time, 0);
599 template <
typename T>
606 if (idx.
size() != instance.
size()+1)
879 { doGetParmValue(idx, instance, value); }
881 { doGetParmValue(idx, instance, value); }
883 { doGetParmValue(idx, instance, value); }
885 { doGetParmValue(idx, instance, value); }
887 { doGetParmValue(idx, instance, value); }
889 { doGetParmValue(idx, instance, value); }
891 { doGetParmValue(idx, instance, value); }
893 { doGetParmValue(idx, instance, value); }
895 { doGetParmValue(idx, instance, value); }
897 { doGetParmValue(idx, instance, value); }
899 { doGetParmValue(idx, instance, value); }
901 template <
typename T>
908 if (idx.
size() != instance.
size()+1)
1084 coerceValue(myReverseSpineDirection, ( ( value ) ));
1126 coerceValue(myUseLocalZScaleAttrib, ( ( value ) ));
1132 coerceValue(myUseLocalInsetScaleAttrib, ( ( value ) ));
1135 coerceValue(myLocalInsetScaleAttrib, ( ( value ) ));
1138 coerceValue(myUseLocalTwistScaleAttrib, ( ( value ) ));
1141 coerceValue(myLocalTwistScaleAttrib, ( ( value ) ));
1144 coerceValue(myUseLocalDivScaleAttrib, ( ( value ) ));
1147 coerceValue(myLocalDivScaleAttrib, ( ( value ) ));
1172 { doSetParmValue(idx, instance, value); }
1174 { doSetParmValue(idx, instance, value); }
1176 { doSetParmValue(idx, instance, value); }
1178 { doSetParmValue(idx, instance, value); }
1180 { doSetParmValue(idx, instance, value); }
1182 { doSetParmValue(idx, instance, value); }
1184 { doSetParmValue(idx, instance, value); }
1186 { doSetParmValue(idx, instance, value); }
1188 { doSetParmValue(idx, instance, value); }
1190 { doSetParmValue(idx, instance, value); }
1192 { doSetParmValue(idx, instance, value); }
1196 if (idx.
size() == 0)
1208 if (fieldnum.
size() < 1)
1210 switch (fieldnum[0])
1217 return "usesplitgroup";
1219 return "splitgroup";
1221 return "extrusionmode";
1223 return "ptnormalsrc";
1225 return "ptnormalattrib";
1237 return "xformfront";
1239 return "xformspace";
1255 return "pivotrotate";
1257 return "prexform_rst";
1259 return "prexform_xyz";
1261 return "prexform_translate";
1263 return "prexform_rotate";
1265 return "prexform_scale";
1267 return "prexform_shear";
1269 return "outputfront";
1271 return "outputfrontgrp";
1275 return "outputback";
1277 return "outputbackgrp";
1281 return "outputside";
1283 return "outputsidegrp";
1287 return "outputfrontseamgrp";
1289 return "frontseamgrp";
1291 return "outputbackseamgrp";
1293 return "backseamgrp";
1295 return "preservegroups";
1297 return "limitinset";
1299 return "commonlimit";
1301 return "addvertexnomrals";
1315 return "frontmagnitude";
1317 return "backmagnitude";
1319 return "frontstiffness";
1321 return "backstiffness";
1323 return "interpolation";
1327 return "reversespinedirection";
1329 return "axialrotation";
1331 return "frontblend";
1335 return "thicknessscale";
1337 return "usethicknessattrib";
1339 return "thicknessattrib";
1341 return "usethicknessramp";
1343 return "thicknessramp";
1345 return "usetwistattrib";
1347 return "twistattrib";
1349 return "usetwistramp";
1353 return "twistscale";
1355 return "uselocalzscaleattrib";
1357 return "localzscaleattrib";
1359 return "uselocalinsetscaleattrib";
1361 return "localinsetscaleattrib";
1363 return "uselocaltwistattrib";
1365 return "localtwistscaleattrib";
1367 return "uselocaldivsattrib";
1369 return "locadivscaleattrib";
1371 return "uselocalxattrib";
1373 return "localxattrib";
1375 return "uselocalzattirb";
1377 return "localzattirb";
1379 return "uselocalctrattrib";
1381 return "localctrattrib";
1389 if (fieldnum.
size() < 1)
1390 return PARM_UNSUPPORTED;
1391 switch (fieldnum[0])
1570 { is.
bread(&v, 1); }
1584 {
for (
int r = 0;
r < 2;
r++)
for (
int c = 0; c < 2; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
1586 {
for (
int r = 0;
r < 3;
r++)
for (
int c = 0; c < 3; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
1588 {
for (
int r = 0;
r < 4;
r++)
for (
int c = 0; c < 4; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
1601 loadData(is, rampdata);
1619 int typelen = colon - data.
buffer();
1631 { UTwrite(os, &v); }
1633 {
int64 iv =
v; UTwrite(os, &iv); }
1635 { UTwrite<fpreal64>(os, &
v); }
1637 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
1639 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1640 UTwrite<fpreal64>(os, &v.
z()); }
1642 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1643 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
1655 if (s) s->save(ostr);
1656 result = ostr.
str();
1657 saveData(os, result);
1664 ostr << s->getDataTypeToken();
1666 s->saveBinary(ostr);
1668 result = ostr.
str();
1669 saveData(os, result);
1677 saveData(os, myGroup);
1678 saveData(os, mySplitType);
1679 saveData(os, myUseSplitGroup);
1680 saveData(os, mySplitGroup);
1681 saveData(os, myExtrusionMode);
1682 saveData(os, myPtNormalSrc);
1683 saveData(os, myPtNormalAttrib);
1684 saveData(os, myDist);
1685 saveData(os, myInset);
1686 saveData(os, myTwist);
1687 saveData(os, myDivs);
1688 saveData(os, mySpineType);
1689 saveData(os, myXformFront);
1690 saveData(os, myXformSpace);
1691 saveData(os, myXformOrder);
1692 saveData(os, myRotateOrder);
1693 saveData(os, myTranslate);
1694 saveData(os, myRotate);
1695 saveData(os, myScale);
1696 saveData(os, myShear);
1697 saveData(os, myPivot);
1698 saveData(os, myPivotRotate);
1699 saveData(os, myPreXformOrder);
1700 saveData(os, myPreXformRotateOrder);
1701 saveData(os, myPreXformTranslate);
1702 saveData(os, myPreXformRotate);
1703 saveData(os, myPreXformScale);
1704 saveData(os, myPreXformShear);
1705 saveData(os, myOutputFront);
1706 saveData(os, myOutputFrontGrp);
1707 saveData(os, myFrontGrp);
1708 saveData(os, myOutputBack);
1709 saveData(os, myOutputBackGrp);
1710 saveData(os, myBackGrp);
1711 saveData(os, myOutputSide);
1712 saveData(os, myOutputSideGrp);
1713 saveData(os, mySideGrp);
1714 saveData(os, myOutputFrontSeamGrp);
1715 saveData(os, myFrontSeamGrp);
1716 saveData(os, myOutputBackSeamGrp);
1717 saveData(os, myBackSeamGrp);
1718 saveData(os, myPreserveGroups);
1719 saveData(os, myLimitInset);
1720 saveData(os, myCommonLimit);
1721 saveData(os, myAddVertexNormals);
1722 saveData(os, myCuspAngle);
1723 saveData(os, myCuspFront);
1724 saveData(os, myCuspBack);
1725 saveData(os, myGenUVs);
1726 saveData(os, myUVStyle);
1727 saveData(os, myUVScaling);
1728 saveData(os, myFrontMagnitude);
1729 saveData(os, myBackMagnitude);
1730 saveData(os, myFrontStiffness);
1731 saveData(os, myBackStiffness);
1732 saveData(os, myInterpolation);
1733 saveData(os, mySpacing);
1734 saveData(os, myReverseSpineDirection);
1735 saveData(os, myAxialRotation);
1736 saveData(os, myFrontBlend);
1737 saveData(os, myBackBlend);
1738 saveData(os, myThicknessScale);
1739 saveData(os, myUseThicknessAttrib);
1740 saveData(os, myThicknessAttrib);
1741 saveData(os, myUseThicknessRamp);
1742 saveData(os, myThicknessRamp);
1743 saveData(os, myUseTwistAttrib);
1744 saveData(os, myTwistAttrib);
1745 saveData(os, myUseTwistRamp);
1746 saveData(os, myTwistRamp);
1747 saveData(os, myTwistScale);
1748 saveData(os, myUseLocalZScaleAttrib);
1749 saveData(os, myLocalZScaleAttrib);
1750 saveData(os, myUseLocalInsetScaleAttrib);
1751 saveData(os, myLocalInsetScaleAttrib);
1752 saveData(os, myUseLocalTwistScaleAttrib);
1753 saveData(os, myLocalTwistScaleAttrib);
1754 saveData(os, myUseLocalDivScaleAttrib);
1755 saveData(os, myLocalDivScaleAttrib);
1756 saveData(os, myUseLocalXAttrib);
1757 saveData(os, myLocalXAttrib);
1758 saveData(os, myUseLocalZAttrib);
1759 saveData(os, myLocalZAttrib);
1760 saveData(os, myUseLocalCtrAttrib);
1761 saveData(os, myLocalCtrAttrib);
1774 loadData(is, myGroup);
1775 loadData(is, mySplitType);
1776 loadData(is, myUseSplitGroup);
1777 loadData(is, mySplitGroup);
1778 loadData(is, myExtrusionMode);
1779 loadData(is, myPtNormalSrc);
1780 loadData(is, myPtNormalAttrib);
1781 loadData(is, myDist);
1782 loadData(is, myInset);
1783 loadData(is, myTwist);
1784 loadData(is, myDivs);
1785 loadData(is, mySpineType);
1786 loadData(is, myXformFront);
1787 loadData(is, myXformSpace);
1788 loadData(is, myXformOrder);
1789 loadData(is, myRotateOrder);
1790 loadData(is, myTranslate);
1791 loadData(is, myRotate);
1792 loadData(is, myScale);
1793 loadData(is, myShear);
1794 loadData(is, myPivot);
1795 loadData(is, myPivotRotate);
1796 loadData(is, myPreXformOrder);
1797 loadData(is, myPreXformRotateOrder);
1798 loadData(is, myPreXformTranslate);
1799 loadData(is, myPreXformRotate);
1800 loadData(is, myPreXformScale);
1801 loadData(is, myPreXformShear);
1802 loadData(is, myOutputFront);
1803 loadData(is, myOutputFrontGrp);
1804 loadData(is, myFrontGrp);
1805 loadData(is, myOutputBack);
1806 loadData(is, myOutputBackGrp);
1807 loadData(is, myBackGrp);
1808 loadData(is, myOutputSide);
1809 loadData(is, myOutputSideGrp);
1810 loadData(is, mySideGrp);
1811 loadData(is, myOutputFrontSeamGrp);
1812 loadData(is, myFrontSeamGrp);
1813 loadData(is, myOutputBackSeamGrp);
1814 loadData(is, myBackSeamGrp);
1815 loadData(is, myPreserveGroups);
1816 loadData(is, myLimitInset);
1817 loadData(is, myCommonLimit);
1818 loadData(is, myAddVertexNormals);
1819 loadData(is, myCuspAngle);
1820 loadData(is, myCuspFront);
1821 loadData(is, myCuspBack);
1822 loadData(is, myGenUVs);
1823 loadData(is, myUVStyle);
1824 loadData(is, myUVScaling);
1825 loadData(is, myFrontMagnitude);
1826 loadData(is, myBackMagnitude);
1827 loadData(is, myFrontStiffness);
1828 loadData(is, myBackStiffness);
1829 loadData(is, myInterpolation);
1830 loadData(is, mySpacing);
1831 loadData(is, myReverseSpineDirection);
1832 loadData(is, myAxialRotation);
1833 loadData(is, myFrontBlend);
1834 loadData(is, myBackBlend);
1835 loadData(is, myThicknessScale);
1836 loadData(is, myUseThicknessAttrib);
1837 loadData(is, myThicknessAttrib);
1838 loadData(is, myUseThicknessRamp);
1839 loadData(is, myThicknessRamp);
1840 loadData(is, myUseTwistAttrib);
1841 loadData(is, myTwistAttrib);
1842 loadData(is, myUseTwistRamp);
1843 loadData(is, myTwistRamp);
1844 loadData(is, myTwistScale);
1845 loadData(is, myUseLocalZScaleAttrib);
1846 loadData(is, myLocalZScaleAttrib);
1847 loadData(is, myUseLocalInsetScaleAttrib);
1848 loadData(is, myLocalInsetScaleAttrib);
1849 loadData(is, myUseLocalTwistScaleAttrib);
1850 loadData(is, myLocalTwistScaleAttrib);
1851 loadData(is, myUseLocalDivScaleAttrib);
1852 loadData(is, myLocalDivScaleAttrib);
1853 loadData(is, myUseLocalXAttrib);
1854 loadData(is, myLocalXAttrib);
1855 loadData(is, myUseLocalZAttrib);
1856 loadData(is, myLocalZAttrib);
1857 loadData(is, myUseLocalCtrAttrib);
1858 loadData(is, myLocalCtrAttrib);
1868 if (!thissop)
return getGroup();
1870 OP_Utils::evalOpParm(result, thissop,
"group", cookparms.
getCookTime(), 0);
1878 if (!thissop)
return getSplitType();
1880 OP_Utils::evalOpParm(result, thissop,
"splittype", cookparms.
getCookTime(), 0);
1888 if (!thissop)
return getUseSplitGroup();
1890 OP_Utils::evalOpParm(result, thissop,
"usesplitgroup", cookparms.
getCookTime(), 0);
1898 if (!thissop)
return getSplitGroup();
1900 OP_Utils::evalOpParm(result, thissop,
"splitgroup", cookparms.
getCookTime(), 0);
1908 if (!thissop)
return getExtrusionMode();
1910 OP_Utils::evalOpParm(result, thissop,
"extrusionmode", cookparms.
getCookTime(), 0);
1918 if (!thissop)
return getPtNormalSrc();
1920 OP_Utils::evalOpParm(result, thissop,
"ptnormalsrc", cookparms.
getCookTime(), 0);
1928 if (!thissop)
return getPtNormalAttrib();
1930 OP_Utils::evalOpParm(result, thissop,
"ptnormalattrib", cookparms.
getCookTime(), 0);
1938 if (!thissop)
return getDist();
1940 OP_Utils::evalOpParm(result, thissop,
"dist", cookparms.
getCookTime(), 0);
1948 if (!thissop)
return getInset();
1950 OP_Utils::evalOpParm(result, thissop,
"inset", cookparms.
getCookTime(), 0);
1958 if (!thissop)
return getTwist();
1960 OP_Utils::evalOpParm(result, thissop,
"twist", cookparms.
getCookTime(), 0);
1968 if (!thissop)
return getDivs();
1970 OP_Utils::evalOpParm(result, thissop,
"divs", cookparms.
getCookTime(), 0);
1978 if (!thissop)
return getSpineType();
1980 OP_Utils::evalOpParm(result, thissop,
"spinetype", cookparms.
getCookTime(), 0);
1988 if (!thissop)
return getXformFront();
1990 OP_Utils::evalOpParm(result, thissop,
"xformfront", cookparms.
getCookTime(), 0);
1998 if (!thissop)
return getXformSpace();
2000 OP_Utils::evalOpParm(result, thissop,
"xformspace", cookparms.
getCookTime(), 0);
2008 if (!thissop)
return getXformOrder();
2010 OP_Utils::evalOpParm(result, thissop,
"rst", cookparms.
getCookTime(), 0);
2018 if (!thissop)
return getRotateOrder();
2020 OP_Utils::evalOpParm(result, thissop,
"xyz", cookparms.
getCookTime(), 0);
2028 if (!thissop)
return getTranslate();
2030 OP_Utils::evalOpParm(result, thissop,
"translate", cookparms.
getCookTime(), 0);
2038 if (!thissop)
return getRotate();
2040 OP_Utils::evalOpParm(result, thissop,
"rotate", cookparms.
getCookTime(), 0);
2050 OP_Utils::evalOpParm(result, thissop,
"scale", cookparms.
getCookTime(), 0);
2058 if (!thissop)
return getShear();
2060 OP_Utils::evalOpParm(result, thissop,
"shear", cookparms.
getCookTime(), 0);
2068 if (!thissop)
return getPivot();
2070 OP_Utils::evalOpParm(result, thissop,
"pivot", cookparms.
getCookTime(), 0);
2078 if (!thissop)
return getPivotRotate();
2080 OP_Utils::evalOpParm(result, thissop,
"pivotrotate", cookparms.
getCookTime(), 0);
2088 if (!thissop)
return getPreXformOrder();
2090 OP_Utils::evalOpParm(result, thissop,
"prexform_rst", cookparms.
getCookTime(), 0);
2098 if (!thissop)
return getPreXformRotateOrder();
2100 OP_Utils::evalOpParm(result, thissop,
"prexform_xyz", cookparms.
getCookTime(), 0);
2108 if (!thissop)
return getPreXformTranslate();
2110 OP_Utils::evalOpParm(result, thissop,
"prexform_translate", cookparms.
getCookTime(), 0);
2118 if (!thissop)
return getPreXformRotate();
2120 OP_Utils::evalOpParm(result, thissop,
"prexform_rotate", cookparms.
getCookTime(), 0);
2128 if (!thissop)
return getPreXformScale();
2130 OP_Utils::evalOpParm(result, thissop,
"prexform_scale", cookparms.
getCookTime(), 0);
2138 if (!thissop)
return getPreXformShear();
2140 OP_Utils::evalOpParm(result, thissop,
"prexform_shear", cookparms.
getCookTime(), 0);
2148 if (!thissop)
return getOutputFront();
2150 OP_Utils::evalOpParm(result, thissop,
"outputfront", cookparms.
getCookTime(), 0);
2158 if (!thissop)
return getOutputFrontGrp();
2160 OP_Utils::evalOpParm(result, thissop,
"outputfrontgrp", cookparms.
getCookTime(), 0);
2168 if (!thissop)
return getFrontGrp();
2170 OP_Utils::evalOpParm(result, thissop,
"frontgrp", cookparms.
getCookTime(), 0);
2178 if (!thissop)
return getOutputBack();
2180 OP_Utils::evalOpParm(result, thissop,
"outputback", cookparms.
getCookTime(), 0);
2188 if (!thissop)
return getOutputBackGrp();
2190 OP_Utils::evalOpParm(result, thissop,
"outputbackgrp", cookparms.
getCookTime(), 0);
2198 if (!thissop)
return getBackGrp();
2200 OP_Utils::evalOpParm(result, thissop,
"backgrp", cookparms.
getCookTime(), 0);
2208 if (!thissop)
return getOutputSide();
2210 OP_Utils::evalOpParm(result, thissop,
"outputside", cookparms.
getCookTime(), 0);
2218 if (!thissop)
return getOutputSideGrp();
2220 OP_Utils::evalOpParm(result, thissop,
"outputsidegrp", cookparms.
getCookTime(), 0);
2228 if (!thissop)
return getSideGrp();
2230 OP_Utils::evalOpParm(result, thissop,
"sidegrp", cookparms.
getCookTime(), 0);
2238 if (!thissop)
return getOutputFrontSeamGrp();
2240 OP_Utils::evalOpParm(result, thissop,
"outputfrontseamgrp", cookparms.
getCookTime(), 0);
2248 if (!thissop)
return getFrontSeamGrp();
2250 OP_Utils::evalOpParm(result, thissop,
"frontseamgrp", cookparms.
getCookTime(), 0);
2258 if (!thissop)
return getOutputBackSeamGrp();
2260 OP_Utils::evalOpParm(result, thissop,
"outputbackseamgrp", cookparms.
getCookTime(), 0);
2268 if (!thissop)
return getBackSeamGrp();
2270 OP_Utils::evalOpParm(result, thissop,
"backseamgrp", cookparms.
getCookTime(), 0);
2278 if (!thissop)
return getPreserveGroups();
2280 OP_Utils::evalOpParm(result, thissop,
"preservegroups", cookparms.
getCookTime(), 0);
2288 if (!thissop)
return getLimitInset();
2290 OP_Utils::evalOpParm(result, thissop,
"limitinset", cookparms.
getCookTime(), 0);
2298 if (!thissop)
return getCommonLimit();
2300 OP_Utils::evalOpParm(result, thissop,
"commonlimit", cookparms.
getCookTime(), 0);
2308 if (!thissop)
return getAddVertexNormals();
2310 OP_Utils::evalOpParm(result, thissop,
"addvertexnomrals", cookparms.
getCookTime(), 0);
2318 if (!thissop)
return getCuspAngle();
2320 OP_Utils::evalOpParm(result, thissop,
"cuspangle", cookparms.
getCookTime(), 0);
2328 if (!thissop)
return getCuspFront();
2330 OP_Utils::evalOpParm(result, thissop,
"cuspfront", cookparms.
getCookTime(), 0);
2338 if (!thissop)
return getCuspBack();
2340 OP_Utils::evalOpParm(result, thissop,
"cuspback", cookparms.
getCookTime(), 0);
2348 if (!thissop)
return getGenUVs();
2350 OP_Utils::evalOpParm(result, thissop,
"genuvs", cookparms.
getCookTime(), 0);
2358 if (!thissop)
return getUVStyle();
2360 OP_Utils::evalOpParm(result, thissop,
"uvstyle", cookparms.
getCookTime(), 0);
2368 if (!thissop)
return getUVScaling();
2370 OP_Utils::evalOpParm(result, thissop,
"uvscaling", cookparms.
getCookTime(), 0);
2378 if (!thissop)
return getFrontMagnitude();
2380 OP_Utils::evalOpParm(result, thissop,
"frontmagnitude", cookparms.
getCookTime(), 0);
2388 if (!thissop)
return getBackMagnitude();
2390 OP_Utils::evalOpParm(result, thissop,
"backmagnitude", cookparms.
getCookTime(), 0);
2398 if (!thissop)
return getFrontStiffness();
2400 OP_Utils::evalOpParm(result, thissop,
"frontstiffness", cookparms.
getCookTime(), 0);
2408 if (!thissop)
return getBackStiffness();
2410 OP_Utils::evalOpParm(result, thissop,
"backstiffness", cookparms.
getCookTime(), 0);
2418 if (!thissop)
return getInterpolation();
2420 OP_Utils::evalOpParm(result, thissop,
"interpolation", cookparms.
getCookTime(), 0);
2428 if (!thissop)
return getSpacing();
2430 OP_Utils::evalOpParm(result, thissop,
"spacing", cookparms.
getCookTime(), 0);
2438 if (!thissop)
return getReverseSpineDirection();
2440 OP_Utils::evalOpParm(result, thissop,
"reversespinedirection", cookparms.
getCookTime(), 0);
2448 if (!thissop)
return getAxialRotation();
2450 OP_Utils::evalOpParm(result, thissop,
"axialrotation", cookparms.
getCookTime(), 0);
2458 if (!thissop)
return getFrontBlend();
2460 OP_Utils::evalOpParm(result, thissop,
"frontblend", cookparms.
getCookTime(), 0);
2468 if (!thissop)
return getBackBlend();
2470 OP_Utils::evalOpParm(result, thissop,
"backblend", cookparms.
getCookTime(), 0);
2478 if (!thissop)
return getThicknessScale();
2480 OP_Utils::evalOpParm(result, thissop,
"thicknessscale", cookparms.
getCookTime(), 0);
2488 if (!thissop)
return getUseThicknessAttrib();
2490 OP_Utils::evalOpParm(result, thissop,
"usethicknessattrib", cookparms.
getCookTime(), 0);
2498 if (!thissop)
return getThicknessAttrib();
2500 OP_Utils::evalOpParm(result, thissop,
"thicknessattrib", cookparms.
getCookTime(), 0);
2508 if (!thissop)
return getUseThicknessRamp();
2510 OP_Utils::evalOpParm(result, thissop,
"usethicknessramp", cookparms.
getCookTime(), 0);
2518 if (!thissop)
return getThicknessRamp();
2520 OP_Utils::evalOpParm(result, thissop,
"thicknessramp", cookparms.
getCookTime(), 0);
2528 if (!thissop)
return getUseTwistAttrib();
2530 OP_Utils::evalOpParm(result, thissop,
"usetwistattrib", cookparms.
getCookTime(), 0);
2538 if (!thissop)
return getTwistAttrib();
2540 OP_Utils::evalOpParm(result, thissop,
"twistattrib", cookparms.
getCookTime(), 0);
2548 if (!thissop)
return getUseTwistRamp();
2550 OP_Utils::evalOpParm(result, thissop,
"usetwistramp", cookparms.
getCookTime(), 0);
2558 if (!thissop)
return getTwistRamp();
2560 OP_Utils::evalOpParm(result, thissop,
"twistramp", cookparms.
getCookTime(), 0);
2568 if (!thissop)
return getTwistScale();
2570 OP_Utils::evalOpParm(result, thissop,
"twistscale", cookparms.
getCookTime(), 0);
2578 if (!thissop)
return getUseLocalZScaleAttrib();
2580 OP_Utils::evalOpParm(result, thissop,
"uselocalzscaleattrib", cookparms.
getCookTime(), 0);
2588 if (!thissop)
return getLocalZScaleAttrib();
2590 OP_Utils::evalOpParm(result, thissop,
"localzscaleattrib", cookparms.
getCookTime(), 0);
2598 if (!thissop)
return getUseLocalInsetScaleAttrib();
2600 OP_Utils::evalOpParm(result, thissop,
"uselocalinsetscaleattrib", cookparms.
getCookTime(), 0);
2608 if (!thissop)
return getLocalInsetScaleAttrib();
2610 OP_Utils::evalOpParm(result, thissop,
"localinsetscaleattrib", cookparms.
getCookTime(), 0);
2618 if (!thissop)
return getUseLocalTwistScaleAttrib();
2620 OP_Utils::evalOpParm(result, thissop,
"uselocaltwistattrib", cookparms.
getCookTime(), 0);
2628 if (!thissop)
return getLocalTwistScaleAttrib();
2630 OP_Utils::evalOpParm(result, thissop,
"localtwistscaleattrib", cookparms.
getCookTime(), 0);
2638 if (!thissop)
return getUseLocalDivScaleAttrib();
2640 OP_Utils::evalOpParm(result, thissop,
"uselocaldivsattrib", cookparms.
getCookTime(), 0);
2648 if (!thissop)
return getLocalDivScaleAttrib();
2650 OP_Utils::evalOpParm(result, thissop,
"locadivscaleattrib", cookparms.
getCookTime(), 0);
2658 if (!thissop)
return getUseLocalXAttrib();
2660 OP_Utils::evalOpParm(result, thissop,
"uselocalxattrib", cookparms.
getCookTime(), 0);
2668 if (!thissop)
return getLocalXAttrib();
2670 OP_Utils::evalOpParm(result, thissop,
"localxattrib", cookparms.
getCookTime(), 0);
2678 if (!thissop)
return getUseLocalZAttrib();
2680 OP_Utils::evalOpParm(result, thissop,
"uselocalzattirb", cookparms.
getCookTime(), 0);
2688 if (!thissop)
return getLocalZAttrib();
2690 OP_Utils::evalOpParm(result, thissop,
"localzattirb", cookparms.
getCookTime(), 0);
2698 if (!thissop)
return getUseLocalCtrAttrib();
2700 OP_Utils::evalOpParm(result, thissop,
"uselocalctrattrib", cookparms.
getCookTime(), 0);
2708 if (!thissop)
return getLocalCtrAttrib();
2710 OP_Utils::evalOpParm(result, thissop,
"localctrattrib", cookparms.
getCookTime(), 0);
2717 bool myUseSplitGroup;
2719 int64 myExtrusionMode;
2720 int64 myPtNormalSrc;
2730 int64 myRotateOrder;
2737 int64 myPreXformOrder;
2738 int64 myPreXformRotateOrder;
2744 bool myOutputFrontGrp;
2747 bool myOutputBackGrp;
2750 bool myOutputSideGrp;
2752 bool myOutputFrontSeamGrp;
2754 bool myOutputBackSeamGrp;
2756 bool myPreserveGroups;
2759 bool myAddVertexNormals;
2770 int64 myInterpolation;
2772 bool myReverseSpineDirection;
2777 bool myUseThicknessAttrib;
2779 bool myUseThicknessRamp;
2781 bool myUseTwistAttrib;
2783 bool myUseTwistRamp;
2786 bool myUseLocalZScaleAttrib;
2788 bool myUseLocalInsetScaleAttrib;
2790 bool myUseLocalTwistScaleAttrib;
2792 bool myUseLocalDivScaleAttrib;
2794 bool myUseLocalXAttrib;
2796 bool myUseLocalZAttrib;
2798 bool myUseLocalCtrAttrib;
bool opUseLocalTwistScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseLocalZAttrib() const
UT_StringHolder opSplitGroup(const SOP_NodeVerb::CookParms &cookparms) const
void setAxialRotation(fpreal64 val)
fpreal64 getAxialRotation() const
fpreal64 getCuspAngle() const
void setUseLocalCtrAttrib(bool val)
bool getCommonLimit() const
fpreal64 getThicknessScale() const
void setCuspAngle(fpreal64 val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
void setPreXformRotate(UT_Vector3D val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
bool getReverseSpineDirection() const
bool opOutputBackSeamGrp(const SOP_NodeVerb::CookParms &cookparms) const
void setPivotRotate(UT_Vector3D val)
static void saveData(std::ostream &os, UT_Matrix4D v)
void setThicknessRamp(UT_SharedPtr< UT_Ramp > val)
void setPivot(UT_Vector3D val)
void setSpacing(Spacing val)
int64 opDivs(const SOP_NodeVerb::CookParms &cookparms) const
bool opCommonLimit(const SOP_NodeVerb::CookParms &cookparms) const
SOP_Node * getNode() const
void setOutputBackSeamGrp(bool val)
void setBackGrp(const UT_StringHolder &val)
bool getOutputBackGrp() const
PtNormalSrc getPtNormalSrc() const
UT_StringHolder opLocalZAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setGroup(const UT_StringHolder &val)
UT_StringHolder opLocalZScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseLocalXAttrib() const
void setOutputFrontGrp(bool val)
const UT_StringHolder & getSideGrp() const
UT_Vector3D opPreXformShear(const SOP_NodeVerb::CookParms &cookparms) const
UT_SharedPtr< UT_Ramp > getThicknessRamp() const
const UT_StringHolder & getSplitGroup() const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
T clampMaxValue(fpreal maxvalue, const T &src) const
fpreal64 getFrontStiffness() const
void setUseLocalZScaleAttrib(bool val)
UT_Vector3D getPreXformTranslate() const
UT_Vector3D getPivot() const
void setFrontStiffness(fpreal64 val)
void setLocalInsetScaleAttrib(const UT_StringHolder &val)
fpreal64 getTwistScale() const
exint bread(int32 *buffer, exint asize=1)
bool opOutputBack(const SOP_NodeVerb::CookParms &cookparms) const
GT_API const UT_StringHolder time
UT_Vector3D opScale(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & y() noexcept
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
void setScale(UT_Vector3D val)
UT_StringHolder opTwistAttrib(const SOP_NodeVerb::CookParms &cookparms) const
ExtrusionMode opExtrusionMode(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix2D v)
static void loadData(UT_IStream &is, int64 &v)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
UT_StringHolder opPtNormalAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setReverseSpineDirection(bool val)
bool getUseThicknessAttrib() const
bool getUseThicknessRamp() const
bool getUseLocalTwistScaleAttrib() const
const OP_Context & context() const
fpreal64 opBackMagnitude(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getTwist() const
void setUVStyle(UVStyle val)
fpreal64 getBackMagnitude() const
constexpr SYS_FORCE_INLINE T & z() noexcept
void setShear(UT_Vector3D val)
SYS_FORCE_INLINE const char * buffer() const
const UT_StringHolder & getPtNormalAttrib() const
const UT_StringHolder & getBackSeamGrp() const
void setRotate(UT_Vector3D val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
bool opAddVertexNormals(const SOP_NodeVerb::CookParms &cookparms) const
void setLocalZAttrib(const UT_StringHolder &val)
void setLocalZScaleAttrib(const UT_StringHolder &val)
UT_SharedPtr< UT_Ramp > opThicknessRamp(const SOP_NodeVerb::CookParms &cookparms) const
An output stream object that owns its own string buffer storage.
fpreal64 opInset(const SOP_NodeVerb::CookParms &cookparms) const
bool opOutputFrontGrp(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
bool opUseLocalInsetScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getInset() const
UT_Vector3D getTranslate() const
void setCuspFront(bool val)
bool opUseThicknessRamp(const SOP_NodeVerb::CookParms &cookparms) const
**But if you need a result
bool opUseLocalDivScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opDist(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
bool opOutputFrontSeamGrp(const SOP_NodeVerb::CookParms &cookparms) const
XformSpace getXformSpace() const
static void saveData(std::ostream &os, bool v)
T clampMinValue(fpreal minvalue, const T &src) const
fpreal64 opFrontStiffness(const SOP_NodeVerb::CookParms &cookparms) const
void setUseTwistRamp(bool val)
static void loadData(UT_IStream &is, fpreal64 &v)
bool opUseLocalZScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool getOutputBackSeamGrp() const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void setCuspBack(bool val)
void copyFrom(const OP_NodeParms *src) override
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
UVScaling opUVScaling(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opFrontSeamGrp(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opFrontBlend(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getLocalZAttrib() const
void setSplitGroup(const UT_StringHolder &val)
virtual NodeIdx getInput(NodeIdx idx, int input, bool markused=false) const =0
constexpr SYS_FORCE_INLINE T & x() noexcept
bool getUseSplitGroup() const
void setInterpolation(Interpolation val)
SpineType getSpineType() const
static void loadData(UT_IStream &is, UT_Vector2I &v)
UT_StringHolder opThicknessAttrib(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opFrontGrp(const SOP_NodeVerb::CookParms &cookparms) const
void setBackStiffness(fpreal64 val)
const UT_StringHolder & getBackGrp() const
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setInset(fpreal64 val)
const UT_StringHolder & getGroup() const
const UT_StringHolder & getTwistAttrib() const
void setOutputBackGrp(bool val)
constexpr SYS_FORCE_INLINE T & x() noexcept
bool getOutputFrontSeamGrp() const
void setOutputBack(bool val)
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
const UT_StringHolder & getThicknessAttrib() const
UT_Vector3D opPreXformRotate(const SOP_NodeVerb::CookParms &cookparms) const
void setUseLocalInsetScaleAttrib(bool val)
void setRotateOrder(RotateOrder val)
const UT_StringHolder & getLocalCtrAttrib() const
static void loadData(UT_IStream &is, UT_Vector3D &v)
bool getOutputFrontGrp() const
void setUseLocalXAttrib(bool val)
bool getUseTwistRamp() const
UT_StringHolder opLocalTwistScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_StringHolder &v)
void setUseTwistAttrib(bool val)
UT_Vector3D opPreXformScale(const SOP_NodeVerb::CookParms &cookparms) const
PreXformRotateOrder opPreXformRotateOrder(const SOP_NodeVerb::CookParms &cookparms) const
void setUseLocalZAttrib(bool val)
const UT_StringHolder & getLocalDivScaleAttrib() const
fpreal64 getBackStiffness() const
void setDist(fpreal64 val)
PtNormalSrc opPtNormalSrc(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
bool opUseLocalZAttrib(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool opOutputBackGrp(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
bool opGenUVs(const SOP_NodeVerb::CookParms &cookparms) const
void setTwistAttrib(const UT_StringHolder &val)
SpineType opSpineType(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & z() noexcept
void setBackSeamGrp(const UT_StringHolder &val)
bool opOutputSideGrp(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
bool opReverseSpineDirection(const SOP_NodeVerb::CookParms &cookparms) const
PreXformOrder opPreXformOrder(const SOP_NodeVerb::CookParms &cookparms) const
void loadFromOpSubclass(const LoadParms &loadparms) override
UT_Vector3D getPreXformRotate() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
UT_StringHolder opBackSeamGrp(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getBackBlend() const
bool getPreserveGroups() const
UT_StringHolder opLocalInsetScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
const OP_GraphProxy * graph() const
bool getUseLocalInsetScaleAttrib() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
fpreal64 opCuspAngle(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opShear(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opBackBlend(const SOP_NodeVerb::CookParms &cookparms) const
XformOrder getXformOrder() const
bool opPreserveGroups(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getLocalZScaleAttrib() const
UVStyle getUVStyle() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
void setPreXformTranslate(UT_Vector3D val)
static void saveData(std::ostream &os, UT_Matrix3D v)
bool opCuspBack(const SOP_NodeVerb::CookParms &cookparms) const
bool operator!=(const SOP_PolyExtrude_2_0Parms &src) const
bool opUseSplitGroup(const SOP_NodeVerb::CookParms &cookparms) const
void setPreXformScale(UT_Vector3D val)
fpreal64 opFrontMagnitude(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseTwistAttrib(const SOP_NodeVerb::CookParms &cookparms) const
Spacing getSpacing() const
bool getUseLocalZScaleAttrib() const
fpreal64 opAxialRotation(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3I &v)
bool getUseLocalDivScaleAttrib() const
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
void setSideGrp(const UT_StringHolder &val)
bool getOutputSide() const
void setBackMagnitude(fpreal64 val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
bool getCuspFront() const
bool opUseLocalXAttrib(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3T< fpreal64 > UT_Vector3D
static void saveData(std::ostream &os, UT_Vector3D v)
PreXformRotateOrder getPreXformRotateOrder() const
RotateOrder opRotateOrder(const SOP_NodeVerb::CookParms &cookparms) const
void setThicknessScale(fpreal64 val)
void setXformSpace(XformSpace val)
const UT_StringHolder & getLocalXAttrib() const
bool opLimitInset(const SOP_NodeVerb::CookParms &cookparms) const
void setUseThicknessRamp(bool val)
void setFrontSeamGrp(const UT_StringHolder &val)
void setUseSplitGroup(bool val)
UT_StringHolder opLocalXAttrib(const SOP_NodeVerb::CookParms &cookparms) const
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
void setAddVertexNormals(bool val)
UVScaling getUVScaling() const
void setThicknessAttrib(const UT_StringHolder &val)
void setLimitInset(bool val)
UVStyle opUVStyle(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseLocalCtrAttrib() const
void saveBinary(std::ostream &os) const
Save string to binary stream.
fpreal64 getFrontMagnitude() const
bool getUseTwistAttrib() const
UT_Vector3D opPivot(const SOP_NodeVerb::CookParms &cookparms) const
bool opOutputSide(const SOP_NodeVerb::CookParms &cookparms) const
XformOrder opXformOrder(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getPivotRotate() const
GT_API const UT_StringHolder version
UT_StringHolder opSideGrp(const SOP_NodeVerb::CookParms &cookparms) const
void setTwistRamp(UT_SharedPtr< UT_Ramp > val)
void setTwist(fpreal64 val)
XformSpace opXformSpace(const SOP_NodeVerb::CookParms &cookparms) const
bool opXformFront(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
void setExtrusionMode(ExtrusionMode val)
UT_StringHolder opBackGrp(const SOP_NodeVerb::CookParms &cookparms) const
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
fpreal64 getFrontBlend() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
void setOutputSideGrp(bool val)
const char * getNestParmName(TempIndex fieldnum) const override
UT_Vector3D opPivotRotate(const SOP_NodeVerb::CookParms &cookparms) const
void setUseLocalDivScaleAttrib(bool val)
exint getNestNumParms(TempIndex idx) const override
bool opOutputFront(const SOP_NodeVerb::CookParms &cookparms) const
void setPtNormalSrc(PtNormalSrc val)
void setCommonLimit(bool val)
void coerceValue(T &result, const S &src) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
RotateOrder getRotateOrder() const
const UT_StringHolder & getFrontSeamGrp() const
SOP_PolyExtrude_2_0Parms()
static void loadData(UT_IStream &is, UT_Vector4D &v)
void setLocalCtrAttrib(const UT_StringHolder &val)
fpreal64 opThicknessScale(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opLocalDivScaleAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setBackBlend(fpreal64 val)
DEP_MicroNode * depnode() const
void setPreserveGroups(bool val)
UT_Vector3D opRotate(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseTwistRamp(const SOP_NodeVerb::CookParms &cookparms) const
UT_SharedPtr< UT_Ramp > getTwistRamp() const
Utility class for containing a color ramp.
UT_Vector3D opTranslate(const SOP_NodeVerb::CookParms &cookparms) const
bool getLimitInset() const
UT_Vector3D opPreXformTranslate(const SOP_NodeVerb::CookParms &cookparms) const
bool isParmColorRamp(exint idx) const override
constexpr SYS_FORCE_INLINE T & w() noexcept
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
void setUseThicknessAttrib(bool val)
void setLocalXAttrib(const UT_StringHolder &val)
static void saveData(std::ostream &os, int64 v)
UT_Vector3D getRotate() const
UT_SharedPtr< UT_Ramp > opTwistRamp(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
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 setLocalTwistScaleAttrib(const UT_StringHolder &val)
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
void setPreXformShear(UT_Vector3D val)
fpreal64 opBackStiffness(const SOP_NodeVerb::CookParms &cookparms) const
void setPreXformOrder(PreXformOrder val)
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
bool getOutputSideGrp() const
fpreal64 opTwistScale(const SOP_NodeVerb::CookParms &cookparms) const
bool load(UT_IStream &is)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
Interpolation getInterpolation() const
static void loadData(UT_IStream &is, bool &v)
SplitType opSplitType(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getCookTime() const
void setLocalDivScaleAttrib(const UT_StringHolder &val)
void save(std::ostream &os) const
UT_Vector3D getShear() const
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void setFrontBlend(fpreal64 val)
void setOutputFrontSeamGrp(bool val)
UT_StringHolder opLocalCtrAttrib(const SOP_NodeVerb::CookParms &cookparms) const
const char * findChar(int c) const
fpreal64 opTwist(const SOP_NodeVerb::CookParms &cookparms) const
SplitType getSplitType() const
bool operator==(const SOP_PolyExtrude_2_0Parms &src) const
Spacing opSpacing(const SOP_NodeVerb::CookParms &cookparms) const
void setSpineType(SpineType val)
bool opUseLocalCtrAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
bool opUseThicknessAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setFrontGrp(const UT_StringHolder &val)
PreXformOrder getPreXformOrder() const
ParmType getNestParmType(TempIndex fieldnum) const override
bool opCuspFront(const SOP_NodeVerb::CookParms &cookparms) const
void setPtNormalAttrib(const UT_StringHolder &val)
const UT_StringHolder & getLocalTwistScaleAttrib() const
void setOutputFront(bool val)
void setUVScaling(UVScaling val)
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
constexpr SYS_FORCE_INLINE T & y() noexcept
Interpolation opInterpolation(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector4D v)
void setXformOrder(XformOrder val)
void setFrontMagnitude(fpreal64 val)
bool getOutputBack() const
ExtrusionMode getExtrusionMode() const
UT_Vector3D getScale() const
bool getOutputFront() const
UT_Vector3D getPreXformShear() const
static void saveData(std::ostream &os, fpreal64 v)
void setTwistScale(fpreal64 val)
void setSplitType(SplitType val)
void setUseLocalTwistScaleAttrib(bool val)
static void saveData(std::ostream &os, UT_StringHolder s)
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
UT_Vector3D getPreXformScale() const
constexpr SYS_FORCE_INLINE T & y() noexcept
void setOutputSide(bool val)
SYS_FORCE_INLINE bool isstring() const
void setTranslate(UT_Vector3D val)
bool getAddVertexNormals() const
void setXformFront(bool val)
OP_NodeParms & operator=(const OP_NodeParms &)=default
void setPreXformRotateOrder(PreXformRotateOrder val)
static void saveData(std::ostream &os, UT_Vector2D v)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
bool getXformFront() const
const UT_StringHolder & getLocalInsetScaleAttrib() const
const UT_StringHolder & getFrontGrp() const
constexpr SYS_FORCE_INLINE T & x() noexcept