HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_CurveFrame.proto.h
Go to the documentation of this file.
1 /* Automagically Generated by generate_proto.py
2  * Do not Edit
3  */
4 #pragma once
5 
6 #include <SOP/SOP_NodeVerb.h>
7 #include <SOP/SOP_GraphProxy.h>
8 
9 #include <OP/OP_Utils.h>
10 #include <PRM/PRM_Parm.h>
11 #include <UT/UT_IStream.h>
12 #include <UT/UT_NTStreamUtil.h>
13 #include <UT/UT_Ramp.h>
14 #include <UT/UT_SharedPtr.h>
15 #include <UT/UT_StringHolder.h>
16 #include <UT/UT_StringStream.h>
17 #include <UT/UT_VectorTypes.h>
18 #include <SYS/SYS_Types.h>
19 
20 using namespace UT::Literal;
21 
22 class DEP_MicroNode;
23 namespace SOP_CurveFrameEnums
24 {
25  enum class TangentType
26  {
27  AVGDIR = 0,
28  DIFF,
29  PREV,
30  NEXT,
31  NONE
32  };
33  enum class UpVectorType
34  {
35  NORMAL = 0,
36  X,
37  Y,
38  Z,
39  ATTRIB,
40  CUSTOM
41  };
42  enum class ROrd
43  {
44  XYZ = 0,
45  XZY,
46  YXZ,
47  YZX,
48  ZXY,
49  ZYX
50  };
51  enum class RollPer
52  {
53  EDGE = 0,
54  DISTANCE,
55  ATTRIB,
56  FULLEDGES,
57  FULLDISTANCE
58  };
59  enum class YawPer
60  {
61  EDGE = 0,
62  DISTANCE,
63  ATTRIB,
64  FULLEDGES,
65  FULLDISTANCE
66  };
67  enum class PitchPer
68  {
69  EDGE = 0,
70  DISTANCE,
71  ATTRIB,
72  FULLEDGES,
73  FULLDISTANCE
74  };
75  enum class Class
76  {
77  POINT = 0,
78  VERTEX
79  };
80 }
81 
82 
84 {
85 public:
86  static int version() { return 1; }
87 
89  {
90  myCurveGroup = ""_sh;
91  myTangentType = 0;
92  myContinuousClosed = true;
93  myExtrapolateEndTangents = false;
94  myTransformByAttribs = false;
95  myUpVectorType = 0;
96  myUpVectorAtStart = true;
97  myUseEndUpVector = false;
98  myUpVectorAttrib = "target_up"_sh;
99  myEndUpVectorAttrib = "target_up_end"_sh;
100  myUpVector = UT_Vector3D(0,1,0);
101  myEndUpVector = UT_Vector3D(0,1,0);
102  myROrd = 0;
103  myApplyRoll = false;
104  myRoll = 0;
105  myRollPer = 4;
106  myFullTwists = 0;
107  myIncRoll = 0;
108  myRollAttrib = "roll"_sh;
109  myApplyYaw = false;
110  myYaw = 0;
111  myYawPer = 4;
112  myIncYaw = 0;
113  myYawAttrib = "yaw"_sh;
114  myApplyPitch = false;
115  myPitch = 0;
116  myPitchPer = 4;
117  myIncPitch = 0;
118  myPitchAttrib = "pitch"_sh;
119  myNormalize = true;
120  myScale = 1;
121  myStretchAroundTurns = false;
122  myMaxStretchAroundTurns = 10;
123  myClass = 0;
124  myOutputXAxis = false;
125  myXAxisName = "out"_sh;
126  myOutputYAxis = true;
127  myYAxisName = "up"_sh;
128  myOutputZAxis = true;
129  myZAxisName = "N"_sh;
130  myOutputTranslation = false;
131  myTranslationName = "P"_sh;
132  myOutputQuaternion = false;
133  myQuaternionName = "orient"_sh;
134  myOutputTransform3 = false;
135  myTransform3Name = "transform"_sh;
136  myOutputTransform4 = false;
137  myTransform4Name = "transform"_sh;
138 
139  }
140 
141  explicit SOP_CurveFrameParms(const SOP_CurveFrameParms &) = default;
142 
143  ~SOP_CurveFrameParms() override {}
144 
145  bool operator==(const SOP_CurveFrameParms &src) const
146  {
147  if (myCurveGroup != src.myCurveGroup) return false;
148  if (myTangentType != src.myTangentType) return false;
149  if (myContinuousClosed != src.myContinuousClosed) return false;
150  if (myExtrapolateEndTangents != src.myExtrapolateEndTangents) return false;
151  if (myTransformByAttribs != src.myTransformByAttribs) return false;
152  if (myUpVectorType != src.myUpVectorType) return false;
153  if (myUpVectorAtStart != src.myUpVectorAtStart) return false;
154  if (myUseEndUpVector != src.myUseEndUpVector) return false;
155  if (myUpVectorAttrib != src.myUpVectorAttrib) return false;
156  if (myEndUpVectorAttrib != src.myEndUpVectorAttrib) return false;
157  if (myUpVector != src.myUpVector) return false;
158  if (myEndUpVector != src.myEndUpVector) return false;
159  if (myROrd != src.myROrd) return false;
160  if (myApplyRoll != src.myApplyRoll) return false;
161  if (myRoll != src.myRoll) return false;
162  if (myRollPer != src.myRollPer) return false;
163  if (myFullTwists != src.myFullTwists) return false;
164  if (myIncRoll != src.myIncRoll) return false;
165  if (myRollAttrib != src.myRollAttrib) return false;
166  if (myApplyYaw != src.myApplyYaw) return false;
167  if (myYaw != src.myYaw) return false;
168  if (myYawPer != src.myYawPer) return false;
169  if (myIncYaw != src.myIncYaw) return false;
170  if (myYawAttrib != src.myYawAttrib) return false;
171  if (myApplyPitch != src.myApplyPitch) return false;
172  if (myPitch != src.myPitch) return false;
173  if (myPitchPer != src.myPitchPer) return false;
174  if (myIncPitch != src.myIncPitch) return false;
175  if (myPitchAttrib != src.myPitchAttrib) return false;
176  if (myNormalize != src.myNormalize) return false;
177  if (myScale != src.myScale) return false;
178  if (myStretchAroundTurns != src.myStretchAroundTurns) return false;
179  if (myMaxStretchAroundTurns != src.myMaxStretchAroundTurns) return false;
180  if (myClass != src.myClass) return false;
181  if (myOutputXAxis != src.myOutputXAxis) return false;
182  if (myXAxisName != src.myXAxisName) return false;
183  if (myOutputYAxis != src.myOutputYAxis) return false;
184  if (myYAxisName != src.myYAxisName) return false;
185  if (myOutputZAxis != src.myOutputZAxis) return false;
186  if (myZAxisName != src.myZAxisName) return false;
187  if (myOutputTranslation != src.myOutputTranslation) return false;
188  if (myTranslationName != src.myTranslationName) return false;
189  if (myOutputQuaternion != src.myOutputQuaternion) return false;
190  if (myQuaternionName != src.myQuaternionName) return false;
191  if (myOutputTransform3 != src.myOutputTransform3) return false;
192  if (myTransform3Name != src.myTransform3Name) return false;
193  if (myOutputTransform4 != src.myOutputTransform4) return false;
194  if (myTransform4Name != src.myTransform4Name) return false;
195 
196  return true;
197  }
198  bool operator!=(const SOP_CurveFrameParms &src) const
199  {
200  return !operator==(src);
201  }
209 
210 
211 
212  void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
213  {
214  myCurveGroup = ""_sh;
215  if (true)
216  graph->evalOpParm(myCurveGroup, nodeidx, "group", time, 0);
217  myTangentType = 0;
218  if (true)
219  graph->evalOpParm(myTangentType, nodeidx, "tangenttype", time, 0);
220  myContinuousClosed = true;
221  if (true && ( (!(((int64(getTangentType())==4)))) ) )
222  graph->evalOpParm(myContinuousClosed, nodeidx, "continuousclosed", time, 0);
223  myExtrapolateEndTangents = false;
224  if (true && ( (!(((int64(getTangentType())==4)))) ) )
225  graph->evalOpParm(myExtrapolateEndTangents, nodeidx, "extrapolateendtangents", time, 0);
226  myTransformByAttribs = false;
227  if (true)
228  graph->evalOpParm(myTransformByAttribs, nodeidx, "transformbyattribs", time, 0);
229  myUpVectorType = 0;
230  if (true && ( (!(((int64(getTangentType())==4)))) ) )
231  graph->evalOpParm(myUpVectorType, nodeidx, "upvectortype", time, 0);
232  myUpVectorAtStart = true;
233  if (true && ( (!(((int64(getTangentType())==4)))) ) )
234  graph->evalOpParm(myUpVectorAtStart, nodeidx, "upvectoratstart", time, 0);
235  myUseEndUpVector = false;
236  if (true && ( (!(((int64(getTangentType())==4))||((getUpVectorAtStart()==0)))) ) )
237  graph->evalOpParm(myUseEndUpVector, nodeidx, "useendupvector", time, 0);
238  myUpVectorAttrib = "target_up"_sh;
239  if (true && ( (!(((int64(getTangentType())==4))||((int64(getUpVectorType())!=4))||((int64(getTangentType())==4))||((int64(getUpVectorType())!=4)))) ) )
240  graph->evalOpParm(myUpVectorAttrib, nodeidx, "upvectorattrib", time, 0);
241  myEndUpVectorAttrib = "target_up_end"_sh;
242  if (true && ( (!(((int64(getTangentType())==4))||((int64(getUpVectorType())!=4))||((getUseEndUpVector()==0))||((getUpVectorAtStart()==0))||((int64(getTangentType())==4))||((int64(getUpVectorType())!=4))||((getUseEndUpVector()==0))||((getUpVectorAtStart()==0)))) ) )
243  graph->evalOpParm(myEndUpVectorAttrib, nodeidx, "endupvectorattrib", time, 0);
244  myUpVector = UT_Vector3D(0,1,0);
245  if (true && ( (!(((int64(getTangentType())==4))||((int64(getUpVectorType())!=5))||((int64(getTangentType())==4))||((int64(getUpVectorType())!=5)))) ) )
246  graph->evalOpParm(myUpVector, nodeidx, "upvector", time, 0);
247  myEndUpVector = UT_Vector3D(0,1,0);
248  if (true && ( (!(((int64(getTangentType())==4))||((int64(getUpVectorType())!=5))||((getUseEndUpVector()==0))||((getUpVectorAtStart()==0))||((int64(getTangentType())==4))||((int64(getUpVectorType())!=5))||((getUseEndUpVector()==0))||((getUpVectorAtStart()==0)))) ) )
249  graph->evalOpParm(myEndUpVector, nodeidx, "endupvector", time, 0);
250  myROrd = 0;
251  if (true)
252  graph->evalOpParm(myROrd, nodeidx, "rOrd", time, 0);
253  myApplyRoll = false;
254  if (true)
255  graph->evalOpParm(myApplyRoll, nodeidx, "applyroll", time, 0);
256  myRoll = 0;
257  if (true && ( (!(((getApplyRoll()==0)))) ) )
258  graph->evalOpParm(myRoll, nodeidx, "roll", time, 0);
259  myRollPer = 4;
260  if (true && ( (!(((getApplyRoll()==0)))) ) )
261  graph->evalOpParm(myRollPer, nodeidx, "rollper", time, 0);
262  myFullTwists = 0;
263  if (true && ( (!(((getApplyRoll()==0)))) ) )
264  graph->evalOpParm(myFullTwists, nodeidx, "fulltwists", time, 0);
265  myIncRoll = 0;
266  if (true && ( (!(((getApplyRoll()==0)))) ) )
267  graph->evalOpParm(myIncRoll, nodeidx, "incroll", time, 0);
268  myRollAttrib = "roll"_sh;
269  if (true && ( (!(((getApplyRoll()==0))||((getApplyRoll()==1)&&(int64(getRollPer())!=2))||((getApplyRoll()==0))||((getApplyRoll()==1)&&(int64(getRollPer())!=2)))) ) )
270  graph->evalOpParm(myRollAttrib, nodeidx, "rollattrib", time, 0);
271  myApplyYaw = false;
272  if (true)
273  graph->evalOpParm(myApplyYaw, nodeidx, "applyyaw", time, 0);
274  myYaw = 0;
275  if (true && ( (!(((getApplyYaw()==0)))) ) )
276  graph->evalOpParm(myYaw, nodeidx, "yaw", time, 0);
277  myYawPer = 4;
278  if (true && ( (!(((getApplyYaw()==0)))) ) )
279  graph->evalOpParm(myYawPer, nodeidx, "yawper", time, 0);
280  myIncYaw = 0;
281  if (true && ( (!(((getApplyYaw()==0)))) ) )
282  graph->evalOpParm(myIncYaw, nodeidx, "incyaw", time, 0);
283  myYawAttrib = "yaw"_sh;
284  if (true && ( (!(((getApplyYaw()==0))||((getApplyYaw()==1)&&(int64(getYawPer())!=2))||((getApplyYaw()==0))||((getApplyYaw()==1)&&(int64(getYawPer())!=2)))) ) )
285  graph->evalOpParm(myYawAttrib, nodeidx, "yawattrib", time, 0);
286  myApplyPitch = false;
287  if (true)
288  graph->evalOpParm(myApplyPitch, nodeidx, "applypitch", time, 0);
289  myPitch = 0;
290  if (true && ( (!(((getApplyPitch()==0)))) ) )
291  graph->evalOpParm(myPitch, nodeidx, "pitch", time, 0);
292  myPitchPer = 4;
293  if (true && ( (!(((getApplyPitch()==0)))) ) )
294  graph->evalOpParm(myPitchPer, nodeidx, "pitchper", time, 0);
295  myIncPitch = 0;
296  if (true && ( (!(((getApplyPitch()==0)))) ) )
297  graph->evalOpParm(myIncPitch, nodeidx, "incpitch", time, 0);
298  myPitchAttrib = "pitch"_sh;
299  if (true && ( (!(((getApplyPitch()==0))||((getApplyPitch()==1)&&(int64(getPitchPer())!=2))||((getApplyPitch()==0))||((getApplyPitch()==1)&&(int64(getPitchPer())!=2)))) ) )
300  graph->evalOpParm(myPitchAttrib, nodeidx, "pitchattrib", time, 0);
301  myNormalize = true;
302  if (true)
303  graph->evalOpParm(myNormalize, nodeidx, "normalize", time, 0);
304  myScale = 1;
305  if (true)
306  graph->evalOpParm(myScale, nodeidx, "scale", time, 0);
307  myStretchAroundTurns = false;
308  if (true)
309  graph->evalOpParm(myStretchAroundTurns, nodeidx, "stretcharoundturns", time, 0);
310  myMaxStretchAroundTurns = 10;
311  if (true && ( (!(((getStretchAroundTurns()==0)))) ) )
312  graph->evalOpParm(myMaxStretchAroundTurns, nodeidx, "maxstretcharoundturns", time, 0);
313  myClass = 0;
314  if (true)
315  graph->evalOpParm(myClass, nodeidx, "class", time, 0);
316  myOutputXAxis = false;
317  if (true)
318  graph->evalOpParm(myOutputXAxis, nodeidx, "outputxaxis", time, 0);
319  myXAxisName = "out"_sh;
320  if (true && ( (!(((getOutputXAxis()==0)))) ) )
321  graph->evalOpParm(myXAxisName, nodeidx, "xaxisname", time, 0);
322  myOutputYAxis = true;
323  if (true)
324  graph->evalOpParm(myOutputYAxis, nodeidx, "outputyaxis", time, 0);
325  myYAxisName = "up"_sh;
326  if (true && ( (!(((getOutputYAxis()==0)))) ) )
327  graph->evalOpParm(myYAxisName, nodeidx, "yaxisname", time, 0);
328  myOutputZAxis = true;
329  if (true)
330  graph->evalOpParm(myOutputZAxis, nodeidx, "outputzaxis", time, 0);
331  myZAxisName = "N"_sh;
332  if (true && ( (!(((getOutputZAxis()==0)))) ) )
333  graph->evalOpParm(myZAxisName, nodeidx, "zaxisname", time, 0);
334  myOutputTranslation = false;
335  if (true)
336  graph->evalOpParm(myOutputTranslation, nodeidx, "outputtranslation", time, 0);
337  myTranslationName = "P"_sh;
338  if (true && ( (!(((getOutputTranslation()==0)))) ) )
339  graph->evalOpParm(myTranslationName, nodeidx, "translationname", time, 0);
340  myOutputQuaternion = false;
341  if (true)
342  graph->evalOpParm(myOutputQuaternion, nodeidx, "outputquaternion", time, 0);
343  myQuaternionName = "orient"_sh;
344  if (true && ( (!(((getOutputQuaternion()==0)))) ) )
345  graph->evalOpParm(myQuaternionName, nodeidx, "quaternionname", time, 0);
346  myOutputTransform3 = false;
347  if (true)
348  graph->evalOpParm(myOutputTransform3, nodeidx, "outputtransform3", time, 0);
349  myTransform3Name = "transform"_sh;
350  if (true && ( (!(((getOutputTransform3()==0)))) ) )
351  graph->evalOpParm(myTransform3Name, nodeidx, "transform3name", time, 0);
352  myOutputTransform4 = false;
353  if (true)
354  graph->evalOpParm(myOutputTransform4, nodeidx, "outputtransform4", time, 0);
355  myTransform4Name = "transform"_sh;
356  if (true && ( (!(((getOutputTransform4()==0)))) ) )
357  graph->evalOpParm(myTransform4Name, nodeidx, "transform4name", time, 0);
358 
359  }
360 
361 
362  void loadFromOpSubclass(const LoadParms &loadparms) override
363  {
364  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
365  }
366 
367 
368  void copyFrom(const SOP_NodeParms *src) override
369  {
370  *this = *((const SOP_CurveFrameParms *)src);
371  }
372 
373  template <typename T>
374  void
375  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
376  {
377  if (idx.size() < 1)
378  return;
379  UT_ASSERT(idx.size() == instance.size()+1);
380  if (idx.size() != instance.size()+1)
381  return;
382  switch (idx[0])
383  {
384  case 0:
385  coerceValue(value, myCurveGroup);
386  break;
387  case 1:
388  coerceValue(value, myTangentType);
389  break;
390  case 2:
391  coerceValue(value, myContinuousClosed);
392  break;
393  case 3:
394  coerceValue(value, myExtrapolateEndTangents);
395  break;
396  case 4:
397  coerceValue(value, myTransformByAttribs);
398  break;
399  case 5:
400  coerceValue(value, myUpVectorType);
401  break;
402  case 6:
403  coerceValue(value, myUpVectorAtStart);
404  break;
405  case 7:
406  coerceValue(value, myUseEndUpVector);
407  break;
408  case 8:
409  coerceValue(value, myUpVectorAttrib);
410  break;
411  case 9:
412  coerceValue(value, myEndUpVectorAttrib);
413  break;
414  case 10:
415  coerceValue(value, myUpVector);
416  break;
417  case 11:
418  coerceValue(value, myEndUpVector);
419  break;
420  case 12:
421  coerceValue(value, myROrd);
422  break;
423  case 13:
424  coerceValue(value, myApplyRoll);
425  break;
426  case 14:
427  coerceValue(value, myRoll);
428  break;
429  case 15:
430  coerceValue(value, myRollPer);
431  break;
432  case 16:
433  coerceValue(value, myFullTwists);
434  break;
435  case 17:
436  coerceValue(value, myIncRoll);
437  break;
438  case 18:
439  coerceValue(value, myRollAttrib);
440  break;
441  case 19:
442  coerceValue(value, myApplyYaw);
443  break;
444  case 20:
445  coerceValue(value, myYaw);
446  break;
447  case 21:
448  coerceValue(value, myYawPer);
449  break;
450  case 22:
451  coerceValue(value, myIncYaw);
452  break;
453  case 23:
454  coerceValue(value, myYawAttrib);
455  break;
456  case 24:
457  coerceValue(value, myApplyPitch);
458  break;
459  case 25:
460  coerceValue(value, myPitch);
461  break;
462  case 26:
463  coerceValue(value, myPitchPer);
464  break;
465  case 27:
466  coerceValue(value, myIncPitch);
467  break;
468  case 28:
469  coerceValue(value, myPitchAttrib);
470  break;
471  case 29:
472  coerceValue(value, myNormalize);
473  break;
474  case 30:
475  coerceValue(value, myScale);
476  break;
477  case 31:
478  coerceValue(value, myStretchAroundTurns);
479  break;
480  case 32:
481  coerceValue(value, myMaxStretchAroundTurns);
482  break;
483  case 33:
484  coerceValue(value, myClass);
485  break;
486  case 34:
487  coerceValue(value, myOutputXAxis);
488  break;
489  case 35:
490  coerceValue(value, myXAxisName);
491  break;
492  case 36:
493  coerceValue(value, myOutputYAxis);
494  break;
495  case 37:
496  coerceValue(value, myYAxisName);
497  break;
498  case 38:
499  coerceValue(value, myOutputZAxis);
500  break;
501  case 39:
502  coerceValue(value, myZAxisName);
503  break;
504  case 40:
505  coerceValue(value, myOutputTranslation);
506  break;
507  case 41:
508  coerceValue(value, myTranslationName);
509  break;
510  case 42:
511  coerceValue(value, myOutputQuaternion);
512  break;
513  case 43:
514  coerceValue(value, myQuaternionName);
515  break;
516  case 44:
517  coerceValue(value, myOutputTransform3);
518  break;
519  case 45:
520  coerceValue(value, myTransform3Name);
521  break;
522  case 46:
523  coerceValue(value, myOutputTransform4);
524  break;
525  case 47:
526  coerceValue(value, myTransform4Name);
527  break;
528 
529  }
530  }
531 
532  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
533  { doGetParmValue(idx, instance, value); }
534  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
535  { doGetParmValue(idx, instance, value); }
536  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
537  { doGetParmValue(idx, instance, value); }
538  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
539  { doGetParmValue(idx, instance, value); }
540  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
541  { doGetParmValue(idx, instance, value); }
542  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
543  { doGetParmValue(idx, instance, value); }
544  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
545  { doGetParmValue(idx, instance, value); }
546  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
547  { doGetParmValue(idx, instance, value); }
548  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
549  { doGetParmValue(idx, instance, value); }
550  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
551  { doGetParmValue(idx, instance, value); }
552  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
553  { doGetParmValue(idx, instance, value); }
554 
555  template <typename T>
556  void
557  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
558  {
559  if (idx.size() < 1)
560  return;
561  UT_ASSERT(idx.size() == instance.size()+1);
562  if (idx.size() != instance.size()+1)
563  return;
564  switch (idx[0])
565  {
566  case 0:
567  coerceValue(myCurveGroup, value);
568  break;
569  case 1:
570  coerceValue(myTangentType, value);
571  break;
572  case 2:
573  coerceValue(myContinuousClosed, value);
574  break;
575  case 3:
576  coerceValue(myExtrapolateEndTangents, value);
577  break;
578  case 4:
579  coerceValue(myTransformByAttribs, value);
580  break;
581  case 5:
582  coerceValue(myUpVectorType, value);
583  break;
584  case 6:
585  coerceValue(myUpVectorAtStart, value);
586  break;
587  case 7:
588  coerceValue(myUseEndUpVector, value);
589  break;
590  case 8:
591  coerceValue(myUpVectorAttrib, value);
592  break;
593  case 9:
594  coerceValue(myEndUpVectorAttrib, value);
595  break;
596  case 10:
597  coerceValue(myUpVector, value);
598  break;
599  case 11:
600  coerceValue(myEndUpVector, value);
601  break;
602  case 12:
603  coerceValue(myROrd, value);
604  break;
605  case 13:
606  coerceValue(myApplyRoll, value);
607  break;
608  case 14:
609  coerceValue(myRoll, value);
610  break;
611  case 15:
612  coerceValue(myRollPer, value);
613  break;
614  case 16:
615  coerceValue(myFullTwists, value);
616  break;
617  case 17:
618  coerceValue(myIncRoll, value);
619  break;
620  case 18:
621  coerceValue(myRollAttrib, value);
622  break;
623  case 19:
624  coerceValue(myApplyYaw, value);
625  break;
626  case 20:
627  coerceValue(myYaw, value);
628  break;
629  case 21:
630  coerceValue(myYawPer, value);
631  break;
632  case 22:
633  coerceValue(myIncYaw, value);
634  break;
635  case 23:
636  coerceValue(myYawAttrib, value);
637  break;
638  case 24:
639  coerceValue(myApplyPitch, value);
640  break;
641  case 25:
642  coerceValue(myPitch, value);
643  break;
644  case 26:
645  coerceValue(myPitchPer, value);
646  break;
647  case 27:
648  coerceValue(myIncPitch, value);
649  break;
650  case 28:
651  coerceValue(myPitchAttrib, value);
652  break;
653  case 29:
654  coerceValue(myNormalize, value);
655  break;
656  case 30:
657  coerceValue(myScale, value);
658  break;
659  case 31:
660  coerceValue(myStretchAroundTurns, value);
661  break;
662  case 32:
663  coerceValue(myMaxStretchAroundTurns, value);
664  break;
665  case 33:
666  coerceValue(myClass, value);
667  break;
668  case 34:
669  coerceValue(myOutputXAxis, value);
670  break;
671  case 35:
672  coerceValue(myXAxisName, value);
673  break;
674  case 36:
675  coerceValue(myOutputYAxis, value);
676  break;
677  case 37:
678  coerceValue(myYAxisName, value);
679  break;
680  case 38:
681  coerceValue(myOutputZAxis, value);
682  break;
683  case 39:
684  coerceValue(myZAxisName, value);
685  break;
686  case 40:
687  coerceValue(myOutputTranslation, value);
688  break;
689  case 41:
690  coerceValue(myTranslationName, value);
691  break;
692  case 42:
693  coerceValue(myOutputQuaternion, value);
694  break;
695  case 43:
696  coerceValue(myQuaternionName, value);
697  break;
698  case 44:
699  coerceValue(myOutputTransform3, value);
700  break;
701  case 45:
702  coerceValue(myTransform3Name, value);
703  break;
704  case 46:
705  coerceValue(myOutputTransform4, value);
706  break;
707  case 47:
708  coerceValue(myTransform4Name, value);
709  break;
710 
711  }
712  }
713 
714  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
715  { doSetParmValue(idx, instance, value); }
716  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
717  { doSetParmValue(idx, instance, value); }
718  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
719  { doSetParmValue(idx, instance, value); }
720  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
721  { doSetParmValue(idx, instance, value); }
722  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
723  { doSetParmValue(idx, instance, value); }
724  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
725  { doSetParmValue(idx, instance, value); }
726  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
727  { doSetParmValue(idx, instance, value); }
728  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
729  { doSetParmValue(idx, instance, value); }
730  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
731  { doSetParmValue(idx, instance, value); }
732  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
733  { doSetParmValue(idx, instance, value); }
734  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
735  { doSetParmValue(idx, instance, value); }
736 
737  exint getNestNumParms(TempIndex idx) const override
738  {
739  if (idx.size() == 0)
740  return 48;
741  switch (idx[0])
742  {
743 
744  }
745  // Invalid
746  return 0;
747  }
748 
749  const char *getNestParmName(TempIndex fieldnum) const override
750  {
751  if (fieldnum.size() < 1)
752  return 0;
753  switch (fieldnum[0])
754  {
755  case 0:
756  return "group";
757  case 1:
758  return "tangenttype";
759  case 2:
760  return "continuousclosed";
761  case 3:
762  return "extrapolateendtangents";
763  case 4:
764  return "transformbyattribs";
765  case 5:
766  return "upvectortype";
767  case 6:
768  return "upvectoratstart";
769  case 7:
770  return "useendupvector";
771  case 8:
772  return "upvectorattrib";
773  case 9:
774  return "endupvectorattrib";
775  case 10:
776  return "upvector";
777  case 11:
778  return "endupvector";
779  case 12:
780  return "rOrd";
781  case 13:
782  return "applyroll";
783  case 14:
784  return "roll";
785  case 15:
786  return "rollper";
787  case 16:
788  return "fulltwists";
789  case 17:
790  return "incroll";
791  case 18:
792  return "rollattrib";
793  case 19:
794  return "applyyaw";
795  case 20:
796  return "yaw";
797  case 21:
798  return "yawper";
799  case 22:
800  return "incyaw";
801  case 23:
802  return "yawattrib";
803  case 24:
804  return "applypitch";
805  case 25:
806  return "pitch";
807  case 26:
808  return "pitchper";
809  case 27:
810  return "incpitch";
811  case 28:
812  return "pitchattrib";
813  case 29:
814  return "normalize";
815  case 30:
816  return "scale";
817  case 31:
818  return "stretcharoundturns";
819  case 32:
820  return "maxstretcharoundturns";
821  case 33:
822  return "class";
823  case 34:
824  return "outputxaxis";
825  case 35:
826  return "xaxisname";
827  case 36:
828  return "outputyaxis";
829  case 37:
830  return "yaxisname";
831  case 38:
832  return "outputzaxis";
833  case 39:
834  return "zaxisname";
835  case 40:
836  return "outputtranslation";
837  case 41:
838  return "translationname";
839  case 42:
840  return "outputquaternion";
841  case 43:
842  return "quaternionname";
843  case 44:
844  return "outputtransform3";
845  case 45:
846  return "transform3name";
847  case 46:
848  return "outputtransform4";
849  case 47:
850  return "transform4name";
851 
852  }
853  return 0;
854  }
855 
856  ParmType getNestParmType(TempIndex fieldnum) const override
857  {
858  if (fieldnum.size() < 1)
859  return PARM_UNSUPPORTED;
860  switch (fieldnum[0])
861  {
862  case 0:
863  return PARM_STRING;
864  case 1:
865  return PARM_INTEGER;
866  case 2:
867  return PARM_INTEGER;
868  case 3:
869  return PARM_INTEGER;
870  case 4:
871  return PARM_INTEGER;
872  case 5:
873  return PARM_INTEGER;
874  case 6:
875  return PARM_INTEGER;
876  case 7:
877  return PARM_INTEGER;
878  case 8:
879  return PARM_STRING;
880  case 9:
881  return PARM_STRING;
882  case 10:
883  return PARM_VECTOR3;
884  case 11:
885  return PARM_VECTOR3;
886  case 12:
887  return PARM_INTEGER;
888  case 13:
889  return PARM_INTEGER;
890  case 14:
891  return PARM_FLOAT;
892  case 15:
893  return PARM_INTEGER;
894  case 16:
895  return PARM_INTEGER;
896  case 17:
897  return PARM_FLOAT;
898  case 18:
899  return PARM_STRING;
900  case 19:
901  return PARM_INTEGER;
902  case 20:
903  return PARM_FLOAT;
904  case 21:
905  return PARM_INTEGER;
906  case 22:
907  return PARM_FLOAT;
908  case 23:
909  return PARM_STRING;
910  case 24:
911  return PARM_INTEGER;
912  case 25:
913  return PARM_FLOAT;
914  case 26:
915  return PARM_INTEGER;
916  case 27:
917  return PARM_FLOAT;
918  case 28:
919  return PARM_STRING;
920  case 29:
921  return PARM_INTEGER;
922  case 30:
923  return PARM_FLOAT;
924  case 31:
925  return PARM_INTEGER;
926  case 32:
927  return PARM_FLOAT;
928  case 33:
929  return PARM_INTEGER;
930  case 34:
931  return PARM_INTEGER;
932  case 35:
933  return PARM_STRING;
934  case 36:
935  return PARM_INTEGER;
936  case 37:
937  return PARM_STRING;
938  case 38:
939  return PARM_INTEGER;
940  case 39:
941  return PARM_STRING;
942  case 40:
943  return PARM_INTEGER;
944  case 41:
945  return PARM_STRING;
946  case 42:
947  return PARM_INTEGER;
948  case 43:
949  return PARM_STRING;
950  case 44:
951  return PARM_INTEGER;
952  case 45:
953  return PARM_STRING;
954  case 46:
955  return PARM_INTEGER;
956  case 47:
957  return PARM_STRING;
958 
959  }
960  return PARM_UNSUPPORTED;
961  }
962 
963  // Boiler plate to load individual types.
964  static void loadData(UT_IStream &is, int64 &v)
965  { is.bread(&v, 1); }
966  static void loadData(UT_IStream &is, bool &v)
967  { int64 iv; is.bread(&iv, 1); v = iv; }
968  static void loadData(UT_IStream &is, fpreal64 &v)
969  { is.bread<fpreal64>(&v, 1); }
970  static void loadData(UT_IStream &is, UT_Vector2D &v)
971  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
972  static void loadData(UT_IStream &is, UT_Vector3D &v)
973  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
974  is.bread<fpreal64>(&v.z(), 1); }
975  static void loadData(UT_IStream &is, UT_Vector4D &v)
976  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
977  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
978  static void loadData(UT_IStream &is, UT_Matrix2D &v)
979  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
980  static void loadData(UT_IStream &is, UT_Matrix3D &v)
981  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
982  static void loadData(UT_IStream &is, UT_Matrix4D &v)
983  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
984  static void loadData(UT_IStream &is, UT_Vector2I &v)
985  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
986  static void loadData(UT_IStream &is, UT_Vector3I &v)
987  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
988  is.bread<int64>(&v.z(), 1); }
989  static void loadData(UT_IStream &is, UT_Vector4I &v)
990  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
991  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
993  { is.bread(v); }
995  { UT_StringHolder rampdata;
996  loadData(is, rampdata);
997  if (rampdata.isstring())
998  {
999  v.reset(new UT_Ramp());
1000  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
1001  v->load(istr);
1002  }
1003  else v.reset();
1004  }
1007  loadData(is, data);
1008  if (data.isstring())
1009  {
1010  // Find the data type.
1011  const char *colon = UT_StringWrap(data).findChar(':');
1012  if (colon)
1013  {
1014  int typelen = colon - data.buffer();
1016  type.strncpy(data.buffer(), typelen);
1017  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1018 
1019  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1020  }
1021  }
1022  else v.reset();
1023  }
1024 
1025  static void saveData(std::ostream &os, int64 v)
1026  { UTwrite(os, &v); }
1027  static void saveData(std::ostream &os, bool v)
1028  { int64 iv = v; UTwrite(os, &iv); }
1029  static void saveData(std::ostream &os, fpreal64 v)
1030  { UTwrite<fpreal64>(os, &v); }
1031  static void saveData(std::ostream &os, UT_Vector2D v)
1032  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1033  static void saveData(std::ostream &os, UT_Vector3D v)
1034  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1035  UTwrite<fpreal64>(os, &v.z()); }
1036  static void saveData(std::ostream &os, UT_Vector4D v)
1037  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1038  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1039  static void saveData(std::ostream &os, UT_Matrix2D v)
1041  static void saveData(std::ostream &os, UT_Matrix3D v)
1043  static void saveData(std::ostream &os, UT_Matrix4D v)
1045  static void saveData(std::ostream &os, UT_StringHolder s)
1046  { UT_StringWrap(s).saveBinary(os); }
1047  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1049  UT_OStringStream ostr;
1050  if (s) s->save(ostr);
1051  result = ostr.str();
1052  saveData(os, result);
1053  }
1054  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1056  UT_OStringStream ostr;
1057  if (s)
1058  {
1059  ostr << s->getDataTypeToken();
1060  ostr << ":";
1061  s->saveBinary(ostr);
1062  }
1063  result = ostr.str();
1064  saveData(os, result);
1065  }
1066 
1067 
1068  void save(std::ostream &os) const
1069  {
1070  int32 v = version();
1071  UTwrite(os, &v);
1072  saveData(os, myCurveGroup);
1073  saveData(os, myTangentType);
1074  saveData(os, myContinuousClosed);
1075  saveData(os, myExtrapolateEndTangents);
1076  saveData(os, myTransformByAttribs);
1077  saveData(os, myUpVectorType);
1078  saveData(os, myUpVectorAtStart);
1079  saveData(os, myUseEndUpVector);
1080  saveData(os, myUpVectorAttrib);
1081  saveData(os, myEndUpVectorAttrib);
1082  saveData(os, myUpVector);
1083  saveData(os, myEndUpVector);
1084  saveData(os, myROrd);
1085  saveData(os, myApplyRoll);
1086  saveData(os, myRoll);
1087  saveData(os, myRollPer);
1088  saveData(os, myFullTwists);
1089  saveData(os, myIncRoll);
1090  saveData(os, myRollAttrib);
1091  saveData(os, myApplyYaw);
1092  saveData(os, myYaw);
1093  saveData(os, myYawPer);
1094  saveData(os, myIncYaw);
1095  saveData(os, myYawAttrib);
1096  saveData(os, myApplyPitch);
1097  saveData(os, myPitch);
1098  saveData(os, myPitchPer);
1099  saveData(os, myIncPitch);
1100  saveData(os, myPitchAttrib);
1101  saveData(os, myNormalize);
1102  saveData(os, myScale);
1103  saveData(os, myStretchAroundTurns);
1104  saveData(os, myMaxStretchAroundTurns);
1105  saveData(os, myClass);
1106  saveData(os, myOutputXAxis);
1107  saveData(os, myXAxisName);
1108  saveData(os, myOutputYAxis);
1109  saveData(os, myYAxisName);
1110  saveData(os, myOutputZAxis);
1111  saveData(os, myZAxisName);
1112  saveData(os, myOutputTranslation);
1113  saveData(os, myTranslationName);
1114  saveData(os, myOutputQuaternion);
1115  saveData(os, myQuaternionName);
1116  saveData(os, myOutputTransform3);
1117  saveData(os, myTransform3Name);
1118  saveData(os, myOutputTransform4);
1119  saveData(os, myTransform4Name);
1120 
1121  }
1122 
1123  bool load(UT_IStream &is)
1124  {
1125  int32 v;
1126  is.bread(&v, 1);
1127  if (version() != v)
1128  {
1129  // Fail incompatible versions
1130  return false;
1131  }
1132  loadData(is, myCurveGroup);
1133  loadData(is, myTangentType);
1134  loadData(is, myContinuousClosed);
1135  loadData(is, myExtrapolateEndTangents);
1136  loadData(is, myTransformByAttribs);
1137  loadData(is, myUpVectorType);
1138  loadData(is, myUpVectorAtStart);
1139  loadData(is, myUseEndUpVector);
1140  loadData(is, myUpVectorAttrib);
1141  loadData(is, myEndUpVectorAttrib);
1142  loadData(is, myUpVector);
1143  loadData(is, myEndUpVector);
1144  loadData(is, myROrd);
1145  loadData(is, myApplyRoll);
1146  loadData(is, myRoll);
1147  loadData(is, myRollPer);
1148  loadData(is, myFullTwists);
1149  loadData(is, myIncRoll);
1150  loadData(is, myRollAttrib);
1151  loadData(is, myApplyYaw);
1152  loadData(is, myYaw);
1153  loadData(is, myYawPer);
1154  loadData(is, myIncYaw);
1155  loadData(is, myYawAttrib);
1156  loadData(is, myApplyPitch);
1157  loadData(is, myPitch);
1158  loadData(is, myPitchPer);
1159  loadData(is, myIncPitch);
1160  loadData(is, myPitchAttrib);
1161  loadData(is, myNormalize);
1162  loadData(is, myScale);
1163  loadData(is, myStretchAroundTurns);
1164  loadData(is, myMaxStretchAroundTurns);
1165  loadData(is, myClass);
1166  loadData(is, myOutputXAxis);
1167  loadData(is, myXAxisName);
1168  loadData(is, myOutputYAxis);
1169  loadData(is, myYAxisName);
1170  loadData(is, myOutputZAxis);
1171  loadData(is, myZAxisName);
1172  loadData(is, myOutputTranslation);
1173  loadData(is, myTranslationName);
1174  loadData(is, myOutputQuaternion);
1175  loadData(is, myQuaternionName);
1176  loadData(is, myOutputTransform3);
1177  loadData(is, myTransform3Name);
1178  loadData(is, myOutputTransform4);
1179  loadData(is, myTransform4Name);
1180 
1181  return true;
1182  }
1183 
1184  const UT_StringHolder & getCurveGroup() const { return myCurveGroup; }
1185  void setCurveGroup(const UT_StringHolder & val) { myCurveGroup = val; }
1187  {
1188  SOP_Node *thissop = cookparms.getNode();
1189  if (!thissop) return getCurveGroup();
1191  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
1192  return result;
1193  }
1194  TangentType getTangentType() const { return TangentType(myTangentType); }
1195  void setTangentType(TangentType val) { myTangentType = int64(val); }
1197  {
1198  SOP_Node *thissop = cookparms.getNode();
1199  if (!thissop) return getTangentType();
1200  int64 result;
1201  OP_Utils::evalOpParm(result, thissop, "tangenttype", cookparms.getCookTime(), 0);
1202  return TangentType(result);
1203  }
1204  bool getContinuousClosed() const { return myContinuousClosed; }
1205  void setContinuousClosed(bool val) { myContinuousClosed = val; }
1206  bool opContinuousClosed(const SOP_NodeVerb::CookParms &cookparms) const
1207  {
1208  SOP_Node *thissop = cookparms.getNode();
1209  if (!thissop) return getContinuousClosed();
1210  bool result;
1211  OP_Utils::evalOpParm(result, thissop, "continuousclosed", cookparms.getCookTime(), 0);
1212  return result;
1213  }
1214  bool getExtrapolateEndTangents() const { return myExtrapolateEndTangents; }
1215  void setExtrapolateEndTangents(bool val) { myExtrapolateEndTangents = val; }
1217  {
1218  SOP_Node *thissop = cookparms.getNode();
1219  if (!thissop) return getExtrapolateEndTangents();
1220  bool result;
1221  OP_Utils::evalOpParm(result, thissop, "extrapolateendtangents", cookparms.getCookTime(), 0);
1222  return result;
1223  }
1224  bool getTransformByAttribs() const { return myTransformByAttribs; }
1225  void setTransformByAttribs(bool val) { myTransformByAttribs = val; }
1226  bool opTransformByAttribs(const SOP_NodeVerb::CookParms &cookparms) const
1227  {
1228  SOP_Node *thissop = cookparms.getNode();
1229  if (!thissop) return getTransformByAttribs();
1230  bool result;
1231  OP_Utils::evalOpParm(result, thissop, "transformbyattribs", cookparms.getCookTime(), 0);
1232  return result;
1233  }
1234  UpVectorType getUpVectorType() const { return UpVectorType(myUpVectorType); }
1235  void setUpVectorType(UpVectorType val) { myUpVectorType = int64(val); }
1237  {
1238  SOP_Node *thissop = cookparms.getNode();
1239  if (!thissop) return getUpVectorType();
1240  int64 result;
1241  OP_Utils::evalOpParm(result, thissop, "upvectortype", cookparms.getCookTime(), 0);
1242  return UpVectorType(result);
1243  }
1244  bool getUpVectorAtStart() const { return myUpVectorAtStart; }
1245  void setUpVectorAtStart(bool val) { myUpVectorAtStart = val; }
1246  bool opUpVectorAtStart(const SOP_NodeVerb::CookParms &cookparms) const
1247  {
1248  SOP_Node *thissop = cookparms.getNode();
1249  if (!thissop) return getUpVectorAtStart();
1250  bool result;
1251  OP_Utils::evalOpParm(result, thissop, "upvectoratstart", cookparms.getCookTime(), 0);
1252  return result;
1253  }
1254  bool getUseEndUpVector() const { return myUseEndUpVector; }
1255  void setUseEndUpVector(bool val) { myUseEndUpVector = val; }
1256  bool opUseEndUpVector(const SOP_NodeVerb::CookParms &cookparms) const
1257  {
1258  SOP_Node *thissop = cookparms.getNode();
1259  if (!thissop) return getUseEndUpVector();
1260  bool result;
1261  OP_Utils::evalOpParm(result, thissop, "useendupvector", cookparms.getCookTime(), 0);
1262  return result;
1263  }
1264  const UT_StringHolder & getUpVectorAttrib() const { return myUpVectorAttrib; }
1265  void setUpVectorAttrib(const UT_StringHolder & val) { myUpVectorAttrib = val; }
1267  {
1268  SOP_Node *thissop = cookparms.getNode();
1269  if (!thissop) return getUpVectorAttrib();
1271  OP_Utils::evalOpParm(result, thissop, "upvectorattrib", cookparms.getCookTime(), 0);
1272  return result;
1273  }
1274  const UT_StringHolder & getEndUpVectorAttrib() const { return myEndUpVectorAttrib; }
1275  void setEndUpVectorAttrib(const UT_StringHolder & val) { myEndUpVectorAttrib = val; }
1277  {
1278  SOP_Node *thissop = cookparms.getNode();
1279  if (!thissop) return getEndUpVectorAttrib();
1281  OP_Utils::evalOpParm(result, thissop, "endupvectorattrib", cookparms.getCookTime(), 0);
1282  return result;
1283  }
1284  UT_Vector3D getUpVector() const { return myUpVector; }
1285  void setUpVector(UT_Vector3D val) { myUpVector = val; }
1287  {
1288  SOP_Node *thissop = cookparms.getNode();
1289  if (!thissop) return getUpVector();
1291  OP_Utils::evalOpParm(result, thissop, "upvector", cookparms.getCookTime(), 0);
1292  return result;
1293  }
1294  UT_Vector3D getEndUpVector() const { return myEndUpVector; }
1295  void setEndUpVector(UT_Vector3D val) { myEndUpVector = val; }
1297  {
1298  SOP_Node *thissop = cookparms.getNode();
1299  if (!thissop) return getEndUpVector();
1301  OP_Utils::evalOpParm(result, thissop, "endupvector", cookparms.getCookTime(), 0);
1302  return result;
1303  }
1304  ROrd getROrd() const { return ROrd(myROrd); }
1305  void setROrd(ROrd val) { myROrd = int64(val); }
1306  ROrd opROrd(const SOP_NodeVerb::CookParms &cookparms) const
1307  {
1308  SOP_Node *thissop = cookparms.getNode();
1309  if (!thissop) return getROrd();
1310  int64 result;
1311  OP_Utils::evalOpParm(result, thissop, "rOrd", cookparms.getCookTime(), 0);
1312  return ROrd(result);
1313  }
1314  bool getApplyRoll() const { return myApplyRoll; }
1315  void setApplyRoll(bool val) { myApplyRoll = val; }
1316  bool opApplyRoll(const SOP_NodeVerb::CookParms &cookparms) const
1317  {
1318  SOP_Node *thissop = cookparms.getNode();
1319  if (!thissop) return getApplyRoll();
1320  bool result;
1321  OP_Utils::evalOpParm(result, thissop, "applyroll", cookparms.getCookTime(), 0);
1322  return result;
1323  }
1324  fpreal64 getRoll() const { return myRoll; }
1325  void setRoll(fpreal64 val) { myRoll = val; }
1326  fpreal64 opRoll(const SOP_NodeVerb::CookParms &cookparms) const
1327  {
1328  SOP_Node *thissop = cookparms.getNode();
1329  if (!thissop) return getRoll();
1330  fpreal64 result;
1331  OP_Utils::evalOpParm(result, thissop, "roll", cookparms.getCookTime(), 0);
1332  return result;
1333  }
1334  RollPer getRollPer() const { return RollPer(myRollPer); }
1335  void setRollPer(RollPer val) { myRollPer = int64(val); }
1337  {
1338  SOP_Node *thissop = cookparms.getNode();
1339  if (!thissop) return getRollPer();
1340  int64 result;
1341  OP_Utils::evalOpParm(result, thissop, "rollper", cookparms.getCookTime(), 0);
1342  return RollPer(result);
1343  }
1344  int64 getFullTwists() const { return myFullTwists; }
1345  void setFullTwists(int64 val) { myFullTwists = val; }
1347  {
1348  SOP_Node *thissop = cookparms.getNode();
1349  if (!thissop) return getFullTwists();
1350  int64 result;
1351  OP_Utils::evalOpParm(result, thissop, "fulltwists", cookparms.getCookTime(), 0);
1352  return result;
1353  }
1354  fpreal64 getIncRoll() const { return myIncRoll; }
1355  void setIncRoll(fpreal64 val) { myIncRoll = val; }
1357  {
1358  SOP_Node *thissop = cookparms.getNode();
1359  if (!thissop) return getIncRoll();
1360  fpreal64 result;
1361  OP_Utils::evalOpParm(result, thissop, "incroll", cookparms.getCookTime(), 0);
1362  return result;
1363  }
1364  const UT_StringHolder & getRollAttrib() const { return myRollAttrib; }
1365  void setRollAttrib(const UT_StringHolder & val) { myRollAttrib = val; }
1367  {
1368  SOP_Node *thissop = cookparms.getNode();
1369  if (!thissop) return getRollAttrib();
1371  OP_Utils::evalOpParm(result, thissop, "rollattrib", cookparms.getCookTime(), 0);
1372  return result;
1373  }
1374  bool getApplyYaw() const { return myApplyYaw; }
1375  void setApplyYaw(bool val) { myApplyYaw = val; }
1376  bool opApplyYaw(const SOP_NodeVerb::CookParms &cookparms) const
1377  {
1378  SOP_Node *thissop = cookparms.getNode();
1379  if (!thissop) return getApplyYaw();
1380  bool result;
1381  OP_Utils::evalOpParm(result, thissop, "applyyaw", cookparms.getCookTime(), 0);
1382  return result;
1383  }
1384  fpreal64 getYaw() const { return myYaw; }
1385  void setYaw(fpreal64 val) { myYaw = val; }
1386  fpreal64 opYaw(const SOP_NodeVerb::CookParms &cookparms) const
1387  {
1388  SOP_Node *thissop = cookparms.getNode();
1389  if (!thissop) return getYaw();
1390  fpreal64 result;
1391  OP_Utils::evalOpParm(result, thissop, "yaw", cookparms.getCookTime(), 0);
1392  return result;
1393  }
1394  YawPer getYawPer() const { return YawPer(myYawPer); }
1395  void setYawPer(YawPer val) { myYawPer = int64(val); }
1396  YawPer opYawPer(const SOP_NodeVerb::CookParms &cookparms) const
1397  {
1398  SOP_Node *thissop = cookparms.getNode();
1399  if (!thissop) return getYawPer();
1400  int64 result;
1401  OP_Utils::evalOpParm(result, thissop, "yawper", cookparms.getCookTime(), 0);
1402  return YawPer(result);
1403  }
1404  fpreal64 getIncYaw() const { return myIncYaw; }
1405  void setIncYaw(fpreal64 val) { myIncYaw = val; }
1407  {
1408  SOP_Node *thissop = cookparms.getNode();
1409  if (!thissop) return getIncYaw();
1410  fpreal64 result;
1411  OP_Utils::evalOpParm(result, thissop, "incyaw", cookparms.getCookTime(), 0);
1412  return result;
1413  }
1414  const UT_StringHolder & getYawAttrib() const { return myYawAttrib; }
1415  void setYawAttrib(const UT_StringHolder & val) { myYawAttrib = val; }
1417  {
1418  SOP_Node *thissop = cookparms.getNode();
1419  if (!thissop) return getYawAttrib();
1421  OP_Utils::evalOpParm(result, thissop, "yawattrib", cookparms.getCookTime(), 0);
1422  return result;
1423  }
1424  bool getApplyPitch() const { return myApplyPitch; }
1425  void setApplyPitch(bool val) { myApplyPitch = val; }
1426  bool opApplyPitch(const SOP_NodeVerb::CookParms &cookparms) const
1427  {
1428  SOP_Node *thissop = cookparms.getNode();
1429  if (!thissop) return getApplyPitch();
1430  bool result;
1431  OP_Utils::evalOpParm(result, thissop, "applypitch", cookparms.getCookTime(), 0);
1432  return result;
1433  }
1434  fpreal64 getPitch() const { return myPitch; }
1435  void setPitch(fpreal64 val) { myPitch = val; }
1436  fpreal64 opPitch(const SOP_NodeVerb::CookParms &cookparms) const
1437  {
1438  SOP_Node *thissop = cookparms.getNode();
1439  if (!thissop) return getPitch();
1440  fpreal64 result;
1441  OP_Utils::evalOpParm(result, thissop, "pitch", cookparms.getCookTime(), 0);
1442  return result;
1443  }
1444  PitchPer getPitchPer() const { return PitchPer(myPitchPer); }
1445  void setPitchPer(PitchPer val) { myPitchPer = int64(val); }
1447  {
1448  SOP_Node *thissop = cookparms.getNode();
1449  if (!thissop) return getPitchPer();
1450  int64 result;
1451  OP_Utils::evalOpParm(result, thissop, "pitchper", cookparms.getCookTime(), 0);
1452  return PitchPer(result);
1453  }
1454  fpreal64 getIncPitch() const { return myIncPitch; }
1455  void setIncPitch(fpreal64 val) { myIncPitch = val; }
1457  {
1458  SOP_Node *thissop = cookparms.getNode();
1459  if (!thissop) return getIncPitch();
1460  fpreal64 result;
1461  OP_Utils::evalOpParm(result, thissop, "incpitch", cookparms.getCookTime(), 0);
1462  return result;
1463  }
1464  const UT_StringHolder & getPitchAttrib() const { return myPitchAttrib; }
1465  void setPitchAttrib(const UT_StringHolder & val) { myPitchAttrib = val; }
1467  {
1468  SOP_Node *thissop = cookparms.getNode();
1469  if (!thissop) return getPitchAttrib();
1471  OP_Utils::evalOpParm(result, thissop, "pitchattrib", cookparms.getCookTime(), 0);
1472  return result;
1473  }
1474  bool getNormalize() const { return myNormalize; }
1475  void setNormalize(bool val) { myNormalize = val; }
1476  bool opNormalize(const SOP_NodeVerb::CookParms &cookparms) const
1477  {
1478  SOP_Node *thissop = cookparms.getNode();
1479  if (!thissop) return getNormalize();
1480  bool result;
1481  OP_Utils::evalOpParm(result, thissop, "normalize", cookparms.getCookTime(), 0);
1482  return result;
1483  }
1484  fpreal64 getScale() const { return myScale; }
1485  void setScale(fpreal64 val) { myScale = val; }
1486  fpreal64 opScale(const SOP_NodeVerb::CookParms &cookparms) const
1487  {
1488  SOP_Node *thissop = cookparms.getNode();
1489  if (!thissop) return getScale();
1490  fpreal64 result;
1491  OP_Utils::evalOpParm(result, thissop, "scale", cookparms.getCookTime(), 0);
1492  return result;
1493  }
1494  bool getStretchAroundTurns() const { return myStretchAroundTurns; }
1495  void setStretchAroundTurns(bool val) { myStretchAroundTurns = val; }
1496  bool opStretchAroundTurns(const SOP_NodeVerb::CookParms &cookparms) const
1497  {
1498  SOP_Node *thissop = cookparms.getNode();
1499  if (!thissop) return getStretchAroundTurns();
1500  bool result;
1501  OP_Utils::evalOpParm(result, thissop, "stretcharoundturns", cookparms.getCookTime(), 0);
1502  return result;
1503  }
1504  fpreal64 getMaxStretchAroundTurns() const { return myMaxStretchAroundTurns; }
1505  void setMaxStretchAroundTurns(fpreal64 val) { myMaxStretchAroundTurns = val; }
1507  {
1508  SOP_Node *thissop = cookparms.getNode();
1509  if (!thissop) return getMaxStretchAroundTurns();
1510  fpreal64 result;
1511  OP_Utils::evalOpParm(result, thissop, "maxstretcharoundturns", cookparms.getCookTime(), 0);
1512  return result;
1513  }
1514  Class getClass() const { return Class(myClass); }
1515  void setClass(Class val) { myClass = int64(val); }
1516  Class opClass(const SOP_NodeVerb::CookParms &cookparms) const
1517  {
1518  SOP_Node *thissop = cookparms.getNode();
1519  if (!thissop) return getClass();
1520  int64 result;
1521  OP_Utils::evalOpParm(result, thissop, "class", cookparms.getCookTime(), 0);
1522  return Class(result);
1523  }
1524  bool getOutputXAxis() const { return myOutputXAxis; }
1525  void setOutputXAxis(bool val) { myOutputXAxis = val; }
1526  bool opOutputXAxis(const SOP_NodeVerb::CookParms &cookparms) const
1527  {
1528  SOP_Node *thissop = cookparms.getNode();
1529  if (!thissop) return getOutputXAxis();
1530  bool result;
1531  OP_Utils::evalOpParm(result, thissop, "outputxaxis", cookparms.getCookTime(), 0);
1532  return result;
1533  }
1534  const UT_StringHolder & getXAxisName() const { return myXAxisName; }
1535  void setXAxisName(const UT_StringHolder & val) { myXAxisName = val; }
1537  {
1538  SOP_Node *thissop = cookparms.getNode();
1539  if (!thissop) return getXAxisName();
1541  OP_Utils::evalOpParm(result, thissop, "xaxisname", cookparms.getCookTime(), 0);
1542  return result;
1543  }
1544  bool getOutputYAxis() const { return myOutputYAxis; }
1545  void setOutputYAxis(bool val) { myOutputYAxis = val; }
1546  bool opOutputYAxis(const SOP_NodeVerb::CookParms &cookparms) const
1547  {
1548  SOP_Node *thissop = cookparms.getNode();
1549  if (!thissop) return getOutputYAxis();
1550  bool result;
1551  OP_Utils::evalOpParm(result, thissop, "outputyaxis", cookparms.getCookTime(), 0);
1552  return result;
1553  }
1554  const UT_StringHolder & getYAxisName() const { return myYAxisName; }
1555  void setYAxisName(const UT_StringHolder & val) { myYAxisName = val; }
1557  {
1558  SOP_Node *thissop = cookparms.getNode();
1559  if (!thissop) return getYAxisName();
1561  OP_Utils::evalOpParm(result, thissop, "yaxisname", cookparms.getCookTime(), 0);
1562  return result;
1563  }
1564  bool getOutputZAxis() const { return myOutputZAxis; }
1565  void setOutputZAxis(bool val) { myOutputZAxis = val; }
1566  bool opOutputZAxis(const SOP_NodeVerb::CookParms &cookparms) const
1567  {
1568  SOP_Node *thissop = cookparms.getNode();
1569  if (!thissop) return getOutputZAxis();
1570  bool result;
1571  OP_Utils::evalOpParm(result, thissop, "outputzaxis", cookparms.getCookTime(), 0);
1572  return result;
1573  }
1574  const UT_StringHolder & getZAxisName() const { return myZAxisName; }
1575  void setZAxisName(const UT_StringHolder & val) { myZAxisName = val; }
1577  {
1578  SOP_Node *thissop = cookparms.getNode();
1579  if (!thissop) return getZAxisName();
1581  OP_Utils::evalOpParm(result, thissop, "zaxisname", cookparms.getCookTime(), 0);
1582  return result;
1583  }
1584  bool getOutputTranslation() const { return myOutputTranslation; }
1585  void setOutputTranslation(bool val) { myOutputTranslation = val; }
1586  bool opOutputTranslation(const SOP_NodeVerb::CookParms &cookparms) const
1587  {
1588  SOP_Node *thissop = cookparms.getNode();
1589  if (!thissop) return getOutputTranslation();
1590  bool result;
1591  OP_Utils::evalOpParm(result, thissop, "outputtranslation", cookparms.getCookTime(), 0);
1592  return result;
1593  }
1594  const UT_StringHolder & getTranslationName() const { return myTranslationName; }
1595  void setTranslationName(const UT_StringHolder & val) { myTranslationName = val; }
1597  {
1598  SOP_Node *thissop = cookparms.getNode();
1599  if (!thissop) return getTranslationName();
1601  OP_Utils::evalOpParm(result, thissop, "translationname", cookparms.getCookTime(), 0);
1602  return result;
1603  }
1604  bool getOutputQuaternion() const { return myOutputQuaternion; }
1605  void setOutputQuaternion(bool val) { myOutputQuaternion = val; }
1606  bool opOutputQuaternion(const SOP_NodeVerb::CookParms &cookparms) const
1607  {
1608  SOP_Node *thissop = cookparms.getNode();
1609  if (!thissop) return getOutputQuaternion();
1610  bool result;
1611  OP_Utils::evalOpParm(result, thissop, "outputquaternion", cookparms.getCookTime(), 0);
1612  return result;
1613  }
1614  const UT_StringHolder & getQuaternionName() const { return myQuaternionName; }
1615  void setQuaternionName(const UT_StringHolder & val) { myQuaternionName = val; }
1617  {
1618  SOP_Node *thissop = cookparms.getNode();
1619  if (!thissop) return getQuaternionName();
1621  OP_Utils::evalOpParm(result, thissop, "quaternionname", cookparms.getCookTime(), 0);
1622  return result;
1623  }
1624  bool getOutputTransform3() const { return myOutputTransform3; }
1625  void setOutputTransform3(bool val) { myOutputTransform3 = val; }
1626  bool opOutputTransform3(const SOP_NodeVerb::CookParms &cookparms) const
1627  {
1628  SOP_Node *thissop = cookparms.getNode();
1629  if (!thissop) return getOutputTransform3();
1630  bool result;
1631  OP_Utils::evalOpParm(result, thissop, "outputtransform3", cookparms.getCookTime(), 0);
1632  return result;
1633  }
1634  const UT_StringHolder & getTransform3Name() const { return myTransform3Name; }
1635  void setTransform3Name(const UT_StringHolder & val) { myTransform3Name = val; }
1637  {
1638  SOP_Node *thissop = cookparms.getNode();
1639  if (!thissop) return getTransform3Name();
1641  OP_Utils::evalOpParm(result, thissop, "transform3name", cookparms.getCookTime(), 0);
1642  return result;
1643  }
1644  bool getOutputTransform4() const { return myOutputTransform4; }
1645  void setOutputTransform4(bool val) { myOutputTransform4 = val; }
1646  bool opOutputTransform4(const SOP_NodeVerb::CookParms &cookparms) const
1647  {
1648  SOP_Node *thissop = cookparms.getNode();
1649  if (!thissop) return getOutputTransform4();
1650  bool result;
1651  OP_Utils::evalOpParm(result, thissop, "outputtransform4", cookparms.getCookTime(), 0);
1652  return result;
1653  }
1654  const UT_StringHolder & getTransform4Name() const { return myTransform4Name; }
1655  void setTransform4Name(const UT_StringHolder & val) { myTransform4Name = val; }
1657  {
1658  SOP_Node *thissop = cookparms.getNode();
1659  if (!thissop) return getTransform4Name();
1661  OP_Utils::evalOpParm(result, thissop, "transform4name", cookparms.getCookTime(), 0);
1662  return result;
1663  }
1664 
1665 private:
1666  UT_StringHolder myCurveGroup;
1667  int64 myTangentType;
1668  bool myContinuousClosed;
1669  bool myExtrapolateEndTangents;
1670  bool myTransformByAttribs;
1671  int64 myUpVectorType;
1672  bool myUpVectorAtStart;
1673  bool myUseEndUpVector;
1674  UT_StringHolder myUpVectorAttrib;
1675  UT_StringHolder myEndUpVectorAttrib;
1676  UT_Vector3D myUpVector;
1677  UT_Vector3D myEndUpVector;
1678  int64 myROrd;
1679  bool myApplyRoll;
1680  fpreal64 myRoll;
1681  int64 myRollPer;
1682  int64 myFullTwists;
1683  fpreal64 myIncRoll;
1684  UT_StringHolder myRollAttrib;
1685  bool myApplyYaw;
1686  fpreal64 myYaw;
1687  int64 myYawPer;
1688  fpreal64 myIncYaw;
1689  UT_StringHolder myYawAttrib;
1690  bool myApplyPitch;
1691  fpreal64 myPitch;
1692  int64 myPitchPer;
1693  fpreal64 myIncPitch;
1694  UT_StringHolder myPitchAttrib;
1695  bool myNormalize;
1696  fpreal64 myScale;
1697  bool myStretchAroundTurns;
1698  fpreal64 myMaxStretchAroundTurns;
1699  int64 myClass;
1700  bool myOutputXAxis;
1701  UT_StringHolder myXAxisName;
1702  bool myOutputYAxis;
1703  UT_StringHolder myYAxisName;
1704  bool myOutputZAxis;
1705  UT_StringHolder myZAxisName;
1706  bool myOutputTranslation;
1707  UT_StringHolder myTranslationName;
1708  bool myOutputQuaternion;
1709  UT_StringHolder myQuaternionName;
1710  bool myOutputTransform3;
1711  UT_StringHolder myTransform3Name;
1712  bool myOutputTransform4;
1713  UT_StringHolder myTransform4Name;
1714 
1715 };
GLdouble s
Definition: glew.h:1390
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
static void loadData(UT_IStream &is, UT_Matrix3D &v)
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
bool opOutputTranslation(const SOP_NodeVerb::CookParms &cookparms) const
void setStretchAroundTurns(bool val)
void setTranslationName(const UT_StringHolder &val)
TangentType opTangentType(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
void setOutputTransform3(bool val)
void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
fpreal64 opIncPitch(const SOP_NodeVerb::CookParms &cookparms) const
exint nodeIdx() const
Definition: SOP_NodeVerb.h:114
void setContinuousClosed(bool val)
static void saveData(std::ostream &os, UT_Matrix2D v)
UpVectorType opUpVectorType(const SOP_NodeVerb::CookParms &cookparms) const
void setOutputTransform4(bool val)
GLenum src
Definition: glew.h:2410
const UT_StringHolder & getQuaternionName() const
int int32
Definition: SYS_Types.h:39
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:640
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
bool opOutputTransform4(const SOP_NodeVerb::CookParms &cookparms) const
bool opExtrapolateEndTangents(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
const char * getNestParmName(TempIndex fieldnum) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
Class opClass(const SOP_NodeVerb::CookParms &cookparms) const
void setUpVectorAtStart(bool val)
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
UT_Vector3D opUpVector(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
const UT_StringHolder & getYawAttrib() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
bool getOutputTransform3() const
void setExtrapolateEndTangents(bool val)
const UT_StringHolder & getTransform4Name() const
exint bread(int32 *buffer, exint asize=1)
static void loadData(UT_IStream &is, UT_Vector4D &v)
GT_API const UT_StringHolder time
UT_Vector3D getEndUpVector() const
fpreal getTime() const
Definition: OP_Context.h:60
GLuint const GLfloat * val
Definition: glew.h:2794
void setTransform3Name(const UT_StringHolder &val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
bool opOutputTransform3(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getUpVector() const
fpreal64 opRoll(const SOP_NodeVerb::CookParms &cookparms) const
void setRoll(fpreal64 val)
static void loadData(UT_IStream &is, fpreal64 &v)
fpreal64 opIncYaw(const SOP_NodeVerb::CookParms &cookparms) const
int64 exint
Definition: SYS_Types.h:125
const UT_StringHolder & getYAxisName() const
bool opUpVectorAtStart(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
const SOP_GraphProxy * graph() const
Definition: SOP_NodeVerb.h:113
void setXAxisName(const UT_StringHolder &val)
An output stream object that owns its own string buffer storage.
bool getTransformByAttribs() const
void setTransform4Name(const UT_StringHolder &val)
const GLdouble * v
Definition: glew.h:1391
const UT_StringHolder & getRollAttrib() const
void setEndUpVectorAttrib(const UT_StringHolder &val)
void setOutputTranslation(bool val)
static void loadData(UT_IStream &is, UT_Vector4I &v)
void setUpVectorType(UpVectorType val)
bool operator==(const SOP_CurveFrameParms &src) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
static void saveData(std::ostream &os, UT_StringHolder s)
UT_StringHolder opTransform4Name(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
static void saveData(std::ostream &os, UT_Vector3D v)
void copyFrom(const SOP_NodeParms *src) override
void save(std::ostream &os) const
const UT_StringHolder & getTranslationName() const
void setYawPer(YawPer val)
const UT_StringHolder & getUpVectorAttrib() const
void setUpVector(UT_Vector3D val)
bool load(UT_IStream &is)
void setEndUpVector(UT_Vector3D val)
void setIncPitch(fpreal64 val)
bool opOutputQuaternion(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
double fpreal64
Definition: SYS_Types.h:201
void setPitchPer(PitchPer val)
PitchPer getPitchPer() const
static void saveData(std::ostream &os, UT_Vector4D v)
static void saveData(std::ostream &os, bool v)
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
ParmType getNestParmType(TempIndex fieldnum) const override
void setZAxisName(const UT_StringHolder &val)
bool getOutputQuaternion() const
bool getUpVectorAtStart() const
fpreal64 getIncYaw() const
SYS_FORCE_INLINE T & y()
Definition: UT_Vector3.h:513
fpreal64 opYaw(const SOP_NodeVerb::CookParms &cookparms) const
UpVectorType getUpVectorType() const
bool getContinuousClosed() const
exint length() const
void setCurveGroup(const UT_StringHolder &val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
bool opStretchAroundTurns(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
GLint GLenum GLsizei GLint GLsizei const void * data
Definition: glew.h:1379
fpreal64 getIncRoll() const
UT_StringHolder opTransform3Name(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & z()
Definition: UT_Vector3.h:515
static void loadData(UT_IStream &is, bool &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
const GLfloat * c
Definition: glew.h:16296
static void saveData(std::ostream &os, UT_Matrix4D v)
void setPitchAttrib(const UT_StringHolder &val)
const UT_StringHolder & getZAxisName() const
void setYawAttrib(const UT_StringHolder &val)
RollPer opRollPer(const SOP_NodeVerb::CookParms &cookparms) const
long long int64
Definition: SYS_Types.h:116
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
TangentType getTangentType() const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
UT_Vector3T< fpreal64 > UT_Vector3D
static void saveData(std::ostream &os, fpreal64 v)
UT_Vector3D opEndUpVector(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opEndUpVectorAttrib(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getCurveGroup() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
UT_StringHolder opRollAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setOutputQuaternion(bool val)
bool opApplyRoll(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3I &v)
void setIncYaw(fpreal64 val)
bool opApplyYaw(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseEndUpVector(const SOP_NodeVerb::CookParms &cookparms) const
void setUpVectorAttrib(const UT_StringHolder &val)
fpreal64 getScale() const
UT_StringHolder opUpVectorAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
RollPer getRollPer() const
UT_StringHolder opPitchAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool opNormalize(const SOP_NodeVerb::CookParms &cookparms) const
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:121
UT_StringHolder opZAxisName(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opQuaternionName(const SOP_NodeVerb::CookParms &cookparms) const
PitchPer opPitchPer(const SOP_NodeVerb::CookParms &cookparms) const
void setTangentType(TangentType val)
fpreal64 getIncPitch() const
fpreal64 getPitch() const
fpreal64 getMaxStretchAroundTurns() const
void setScale(fpreal64 val)
void setRollAttrib(const UT_StringHolder &val)
bool opTransformByAttribs(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector2D v)
exint getNestNumParms(TempIndex idx) const override
const UT_StringHolder & getPitchAttrib() const
const UT_StringHolder & getXAxisName() const
YawPer opYawPer(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
fpreal64 fpreal
Definition: SYS_Types.h:277
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
bool getOutputTransform4() const
UT_StringHolder opXAxisName(const SOP_NodeVerb::CookParms &cookparms) const
void setUseEndUpVector(bool val)
bool opOutputXAxis(const SOP_NodeVerb::CookParms &cookparms) const
GLdouble GLdouble GLdouble r
Definition: glew.h:1406
void setTransformByAttribs(bool val)
fpreal64 getRoll() const
UT_StringHolder opTranslationName(const SOP_NodeVerb::CookParms &cookparms) const
ROrd opROrd(const SOP_NodeVerb::CookParms &cookparms) const
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.
Definition: Mat.h:648
#define SOP_API
Definition: SOP_API.h:10
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
SYS_FORCE_INLINE T & x()
Definition: UT_Vector3.h:511
bool getOutputTranslation() const
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:654
bool opOutputYAxis(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_StringHolder &v)
static void loadData(UT_IStream &is, UT_Vector2D &v)
static void saveData(std::ostream &os, UT_Matrix3D v)
int64 opFullTwists(const SOP_NodeVerb::CookParms &cookparms) const
GLuint64EXT * result
Definition: glew.h:14007
static void saveData(std::ostream &os, int64 v)
const char * findChar(int c) const
Definition: UT_String.h:1367
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:135
bool operator!=(const SOP_CurveFrameParms &src) const
UT_StringHolder opYAxisName(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
const UT_StringHolder & getEndUpVectorAttrib() const
bool opContinuousClosed(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getYaw() const
static void loadData(UT_IStream &is, int64 &v)
bool getStretchAroundTurns() const
static void loadData(UT_IStream &is, UT_Vector3D &v)
void setRollPer(RollPer val)
GLsizei const GLfloat * value
Definition: glew.h:1849
UT_StringHolder opYawAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool opApplyPitch(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opCurveGroup(const SOP_NodeVerb::CookParms &cookparms) const
const OP_Context & context() const
Definition: SOP_NodeVerb.h:119
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:89
fpreal64 opMaxStretchAroundTurns(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opScale(const SOP_NodeVerb::CookParms &cookparms) const
void loadFromOpSubclass(const LoadParms &loadparms) override
bool opOutputZAxis(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
void setQuaternionName(const UT_StringHolder &val)
void setFullTwists(int64 val)
fpreal64 opPitch(const SOP_NodeVerb::CookParms &cookparms) const
void setYaw(fpreal64 val)
void setPitch(fpreal64 val)
void setYAxisName(const UT_StringHolder &val)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
const UT_StringHolder & getTransform3Name() const
type
Definition: core.h:528
bool getExtrapolateEndTangents() const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void setIncRoll(fpreal64 val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
void setMaxStretchAroundTurns(fpreal64 val)
fpreal64 opIncRoll(const SOP_NodeVerb::CookParms &cookparms) const