HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_FontParms.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 <OP/OP_Utils.h>
8 #include <PRM/PRM_Parm.h>
9 #include <UT/UT_IStream.h>
10 #include <UT/UT_NTStreamUtil.h>
11 #include <UT/UT_Ramp.h>
12 #include <UT/UT_SharedPtr.h>
13 #include <UT/UT_StringHolder.h>
14 #include <UT/UT_StringStream.h>
15 #include <UT/UT_VectorTypes.h>
16 #include <SYS/SYS_Types.h>
17 
18 using namespace UT::Literal;
19 
20 class DEP_MicroNode;
21 
23 {
24 public:
25  static int version() { return 1; }
26 
28  {
29  myType = 2;
30  myFontFile = "Helvetica Bold"_sh;
31  myText = "Frame: $F"_sh;
32  myHAlign = 1;
33  myVAlign = 2;
34  myUseDescender = false;
35  myTranslate = 0;
36  myScale = 1;
37  myFontSize = 1;
38  myTracking = 0;
39  myAutoKern = true;
40  myOblique = 0;
41  myLOD = 1;
42  myHole = true;
43  myAddAttrib = false;
44 
45  }
46 
47  explicit SOP_FontParms(const SOP_FontParms &) = default;
48 
49  virtual ~SOP_FontParms() {}
50 
51  bool operator==(const SOP_FontParms &src) const
52  {
53  if (myType != src.myType) return false;
54  if (myFontFile != src.myFontFile) return false;
55  if (myText != src.myText) return false;
56  if (myHAlign != src.myHAlign) return false;
57  if (myVAlign != src.myVAlign) return false;
58  if (myUseDescender != src.myUseDescender) return false;
59  if (myTranslate != src.myTranslate) return false;
60  if (myScale != src.myScale) return false;
61  if (myFontSize != src.myFontSize) return false;
62  if (myTracking != src.myTracking) return false;
63  if (myAutoKern != src.myAutoKern) return false;
64  if (myOblique != src.myOblique) return false;
65  if (myLOD != src.myLOD) return false;
66  if (myHole != src.myHole) return false;
67  if (myAddAttrib != src.myAddAttrib) return false;
68 
69  return true;
70  }
71 
72 
73 
74  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
75  {
76  if (true)
77  OP_Utils::evalOpParm(myType, node, "type", time, 0);
78  else myType = 2;
79  if (true)
80  OP_Utils::evalOpParm(myFontFile, node, "file", time, 0);
81  else myFontFile = "Helvetica Bold"_sh;
82  if (true)
83  OP_Utils::evalOpParm(myText, node, "text", time, 0);
84  else myText = "Frame: $F"_sh;
85  if (true)
86  OP_Utils::evalOpParm(myHAlign, node, "halign", time, 0);
87  else myHAlign = 1;
88  if (true)
89  OP_Utils::evalOpParm(myVAlign, node, "valign", time, 0);
90  else myVAlign = 2;
91  if (true)
92  OP_Utils::evalOpParm(myUseDescender, node, "use_descender", time, 0);
93  else myUseDescender = false;
94  if (true)
95  OP_Utils::evalOpParm(myTranslate, node, "t", time, 0);
96  else myTranslate = 0;
97  if (true)
98  OP_Utils::evalOpParm(myScale, node, "s", time, 0);
99  else myScale = 1;
100  if (true)
101  OP_Utils::evalOpParm(myFontSize, node, "fontsize", time, 0);
102  else myFontSize = 1;
103  if (true)
104  OP_Utils::evalOpParm(myTracking, node, "tracking", time, 0);
105  else myTracking = 0;
106  if (true)
107  OP_Utils::evalOpParm(myAutoKern, node, "autokern", time, 0);
108  else myAutoKern = true;
109  if (true)
110  OP_Utils::evalOpParm(myOblique, node, "oblique", time, 0);
111  else myOblique = 0;
112  if (true)
113  OP_Utils::evalOpParm(myLOD, node, "lod", time, 0);
114  else myLOD = 1;
115  if (true)
116  OP_Utils::evalOpParm(myHole, node, "hole", time, 0);
117  else myHole = true;
118  if (true)
119  OP_Utils::evalOpParm(myAddAttrib, node, "addattrib", time, 0);
120  else myAddAttrib = false;
121 
122  }
123 
124 
125  virtual void loadFromOpSubclass(const LoadParms &loadparms)
126  {
127  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
128  }
129 
130 
131  virtual void copyFrom(const SOP_NodeParms *src)
132  {
133  *this = *((const SOP_FontParms *)src);
134  }
135 
136  template <typename T>
137  void
138  doGetParmValue(exint idx, T &value) const
139  {
140  switch (idx)
141  {
142  case 0:
143  coerceValue(value, myType);
144  break;
145  case 1:
146  coerceValue(value, myFontFile);
147  break;
148  case 2:
149  coerceValue(value, myText);
150  break;
151  case 3:
152  coerceValue(value, myHAlign);
153  break;
154  case 4:
155  coerceValue(value, myVAlign);
156  break;
157  case 5:
158  coerceValue(value, myUseDescender);
159  break;
160  case 6:
161  coerceValue(value, myTranslate);
162  break;
163  case 7:
164  coerceValue(value, myScale);
165  break;
166  case 8:
167  coerceValue(value, myFontSize);
168  break;
169  case 9:
170  coerceValue(value, myTracking);
171  break;
172  case 10:
173  coerceValue(value, myAutoKern);
174  break;
175  case 11:
176  coerceValue(value, myOblique);
177  break;
178  case 12:
179  coerceValue(value, myLOD);
180  break;
181  case 13:
182  coerceValue(value, myHole);
183  break;
184  case 14:
185  coerceValue(value, myAddAttrib);
186  break;
187 
188  }
189  }
190 
191  void getParmValue(exint idx, exint &value) const
192  { doGetParmValue(idx, value); }
193  void getParmValue(exint idx, fpreal &value) const
194  { doGetParmValue(idx, value); }
196  { doGetParmValue(idx, value); }
198  { doGetParmValue(idx, value); }
200  { doGetParmValue(idx, value); }
202  { doGetParmValue(idx, value); }
204  { doGetParmValue(idx, value); }
206  { doGetParmValue(idx, value); }
208  { doGetParmValue(idx, value); }
210  { doGetParmValue(idx, value); }
212  { doGetParmValue(idx, value); }
213 
214  template <typename T>
215  void
216  doSetParmValue(exint idx, const T &value)
217  {
218  switch (idx)
219  {
220  case 0:
221  coerceValue(myType, value);
222  break;
223  case 1:
224  coerceValue(myFontFile, value);
225  break;
226  case 2:
227  coerceValue(myText, value);
228  break;
229  case 3:
230  coerceValue(myHAlign, value);
231  break;
232  case 4:
233  coerceValue(myVAlign, value);
234  break;
235  case 5:
236  coerceValue(myUseDescender, value);
237  break;
238  case 6:
239  coerceValue(myTranslate, value);
240  break;
241  case 7:
242  coerceValue(myScale, value);
243  break;
244  case 8:
245  coerceValue(myFontSize, value);
246  break;
247  case 9:
248  coerceValue(myTracking, value);
249  break;
250  case 10:
251  coerceValue(myAutoKern, value);
252  break;
253  case 11:
254  coerceValue(myOblique, value);
255  break;
256  case 12:
257  coerceValue(myLOD, value);
258  break;
259  case 13:
260  coerceValue(myHole, value);
261  break;
262  case 14:
263  coerceValue(myAddAttrib, value);
264  break;
265 
266  }
267  }
268 
269  void setParmValue(exint idx, const exint &value)
270  { doSetParmValue(idx, value); }
271  void setParmValue(exint idx, const fpreal &value)
272  { doSetParmValue(idx, value); }
273  void setParmValue(exint idx, const UT_Vector2D &value)
274  { doSetParmValue(idx, value); }
275  void setParmValue(exint idx, const UT_Vector3D &value)
276  { doSetParmValue(idx, value); }
277  void setParmValue(exint idx, const UT_Vector4D &value)
278  { doSetParmValue(idx, value); }
279  void setParmValue(exint idx, const UT_Matrix2D &value)
280  { doSetParmValue(idx, value); }
281  void setParmValue(exint idx, const UT_Matrix3D &value)
282  { doSetParmValue(idx, value); }
283  void setParmValue(exint idx, const UT_Matrix4D &value)
284  { doSetParmValue(idx, value); }
286  { doSetParmValue(idx, value); }
288  { doSetParmValue(idx, value); }
290  { doSetParmValue(idx, value); }
291 
292  virtual exint getNumParms() const
293  {
294  return 15;
295  }
296 
297  virtual const char *getParmName(exint fieldnum) const
298  {
299  switch (fieldnum)
300  {
301  case 0:
302  return "type";
303  case 1:
304  return "file";
305  case 2:
306  return "text";
307  case 3:
308  return "halign";
309  case 4:
310  return "valign";
311  case 5:
312  return "use_descender";
313  case 6:
314  return "t";
315  case 7:
316  return "s";
317  case 8:
318  return "fontsize";
319  case 9:
320  return "tracking";
321  case 10:
322  return "autokern";
323  case 11:
324  return "oblique";
325  case 12:
326  return "lod";
327  case 13:
328  return "hole";
329  case 14:
330  return "addattrib";
331 
332  }
333  return 0;
334  }
335 
336  virtual ParmType getParmType(exint fieldnum) const
337  {
338  switch (fieldnum)
339  {
340  case 0:
341  return PARM_INTEGER;
342  case 1:
343  return PARM_STRING;
344  case 2:
345  return PARM_STRING;
346  case 3:
347  return PARM_INTEGER;
348  case 4:
349  return PARM_INTEGER;
350  case 5:
351  return PARM_INTEGER;
352  case 6:
353  return PARM_VECTOR3;
354  case 7:
355  return PARM_VECTOR2;
356  case 8:
357  return PARM_FLOAT;
358  case 9:
359  return PARM_VECTOR2;
360  case 10:
361  return PARM_INTEGER;
362  case 11:
363  return PARM_FLOAT;
364  case 12:
365  return PARM_FLOAT;
366  case 13:
367  return PARM_INTEGER;
368  case 14:
369  return PARM_INTEGER;
370 
371  }
372  return PARM_UNSUPPORTED;
373  }
374 
375  // Boiler plate to load individual types.
376  static void loadData(UT_IStream &is, int64 &v)
377  { is.bread(&v, 1); }
378  static void loadData(UT_IStream &is, bool &v)
379  { int64 iv; is.bread(&iv, 1); v = iv; }
380  static void loadData(UT_IStream &is, fpreal64 &v)
381  { is.bread<fpreal64>(&v, 1); }
382  static void loadData(UT_IStream &is, UT_Vector2D &v)
383  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
384  static void loadData(UT_IStream &is, UT_Vector3D &v)
385  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
386  is.bread<fpreal64>(&v.z(), 1); }
387  static void loadData(UT_IStream &is, UT_Vector4D &v)
388  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
389  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
390  static void loadData(UT_IStream &is, UT_Matrix2D &v)
391  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
392  static void loadData(UT_IStream &is, UT_Matrix3D &v)
393  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
394  static void loadData(UT_IStream &is, UT_Matrix4D &v)
395  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
396  static void loadData(UT_IStream &is, UT_Vector2I &v)
397  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
398  static void loadData(UT_IStream &is, UT_Vector3I &v)
399  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
400  is.bread<int64>(&v.z(), 1); }
401  static void loadData(UT_IStream &is, UT_Vector4I &v)
402  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
403  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
405  { is.bread(v); }
407  { UT_StringHolder rampdata;
408  loadData(is, rampdata);
409  if (rampdata.isstring())
410  {
411  v.reset(new UT_Ramp());
412  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
413  v->load(istr);
414  }
415  else v.reset();
416  }
419  loadData(is, data);
420  if (data.isstring())
421  {
422  // Find the data type.
423  char *colon = UT_StringWrap(data).findChar(':');
424  if (colon)
425  {
426  int typelen = colon - data.buffer();
428  type.strncpy(data.buffer(), typelen);
429  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
430 
431  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
432  }
433  }
434  else v.reset();
435  }
436 
437  static void saveData(std::ostream &os, int64 v)
438  { UTwrite(os, &v); }
439  static void saveData(std::ostream &os, bool v)
440  { int64 iv = v; UTwrite(os, &iv); }
441  static void saveData(std::ostream &os, fpreal64 v)
442  { UTwrite<fpreal64>(os, &v); }
443  static void saveData(std::ostream &os, UT_Vector2D v)
444  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
445  static void saveData(std::ostream &os, UT_Vector3D v)
446  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
447  UTwrite<fpreal64>(os, &v.z()); }
448  static void saveData(std::ostream &os, UT_Vector4D v)
449  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
450  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
451  static void saveData(std::ostream &os, UT_Matrix2D v)
453  static void saveData(std::ostream &os, UT_Matrix3D v)
455  static void saveData(std::ostream &os, UT_Matrix4D v)
457  static void saveData(std::ostream &os, UT_StringHolder s)
458  { UT_StringWrap(s).saveBinary(os); }
459  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
460  { UT_StringHolder result;
461  UT_OStringStream ostr;
462  if (s) s->save(ostr);
463  result = ostr.str();
464  saveData(os, result);
465  }
466  static void saveData(std::ostream &os, PRM_DataItemHandle s)
467  { UT_StringHolder result;
468  UT_OStringStream ostr;
469  if (s)
470  {
471  ostr << s->getDataTypeToken();
472  ostr << ":";
473  s->saveBinary(ostr);
474  }
475  result = ostr.str();
476  saveData(os, result);
477  }
478 
479 
480  void save(std::ostream &os) const
481  {
482  int32 v = version();
483  UTwrite(os, &v);
484  saveData(os, myType);
485  saveData(os, myFontFile);
486  saveData(os, myText);
487  saveData(os, myHAlign);
488  saveData(os, myVAlign);
489  saveData(os, myUseDescender);
490  saveData(os, myTranslate);
491  saveData(os, myScale);
492  saveData(os, myFontSize);
493  saveData(os, myTracking);
494  saveData(os, myAutoKern);
495  saveData(os, myOblique);
496  saveData(os, myLOD);
497  saveData(os, myHole);
498  saveData(os, myAddAttrib);
499 
500  }
501 
502  bool load(UT_IStream &is)
503  {
504  int32 v;
505  is.bread(&v, 1);
506  if (version() != v)
507  {
508  // Fail incompatible versions
509  return false;
510  }
511  loadData(is, myType);
512  loadData(is, myFontFile);
513  loadData(is, myText);
514  loadData(is, myHAlign);
515  loadData(is, myVAlign);
516  loadData(is, myUseDescender);
517  loadData(is, myTranslate);
518  loadData(is, myScale);
519  loadData(is, myFontSize);
520  loadData(is, myTracking);
521  loadData(is, myAutoKern);
522  loadData(is, myOblique);
523  loadData(is, myLOD);
524  loadData(is, myHole);
525  loadData(is, myAddAttrib);
526 
527  return true;
528  }
529 
530  int64 getType() const { return myType; }
531  void setType(int64 val) { myType = val; }
532  int64 opType(const SOP_NodeVerb::CookParms &cookparms) const
533  {
534  SOP_Node *thissop = cookparms.getNode();
535  if (!thissop) return getType();
536  int64 result;
537  OP_Utils::evalOpParm(result, thissop, "type", cookparms.getCookTime(), 0);
538  return result;
539  }
540  const UT_StringHolder & getFontFile() const { return myFontFile; }
541  void setFontFile(const UT_StringHolder & val) { myFontFile = val; }
543  {
544  SOP_Node *thissop = cookparms.getNode();
545  if (!thissop) return getFontFile();
546  UT_StringHolder result;
547  OP_Utils::evalOpParm(result, thissop, "file", cookparms.getCookTime(), 0);
548  return result;
549  }
550  const UT_StringHolder & getText() const { return myText; }
551  void setText(const UT_StringHolder & val) { myText = val; }
553  {
554  SOP_Node *thissop = cookparms.getNode();
555  if (!thissop) return getText();
556  UT_StringHolder result;
557  OP_Utils::evalOpParm(result, thissop, "text", cookparms.getCookTime(), 0);
558  return result;
559  }
560  int64 getHAlign() const { return myHAlign; }
561  void setHAlign(int64 val) { myHAlign = val; }
562  int64 opHAlign(const SOP_NodeVerb::CookParms &cookparms) const
563  {
564  SOP_Node *thissop = cookparms.getNode();
565  if (!thissop) return getHAlign();
566  int64 result;
567  OP_Utils::evalOpParm(result, thissop, "halign", cookparms.getCookTime(), 0);
568  return result;
569  }
570  int64 getVAlign() const { return myVAlign; }
571  void setVAlign(int64 val) { myVAlign = val; }
572  int64 opVAlign(const SOP_NodeVerb::CookParms &cookparms) const
573  {
574  SOP_Node *thissop = cookparms.getNode();
575  if (!thissop) return getVAlign();
576  int64 result;
577  OP_Utils::evalOpParm(result, thissop, "valign", cookparms.getCookTime(), 0);
578  return result;
579  }
580  bool getUseDescender() const { return myUseDescender; }
581  void setUseDescender(bool val) { myUseDescender = val; }
582  bool opUseDescender(const SOP_NodeVerb::CookParms &cookparms) const
583  {
584  SOP_Node *thissop = cookparms.getNode();
585  if (!thissop) return getUseDescender();
586  bool result;
587  OP_Utils::evalOpParm(result, thissop, "use_descender", cookparms.getCookTime(), 0);
588  return result;
589  }
590  UT_Vector3D getTranslate() const { return myTranslate; }
591  void setTranslate(UT_Vector3D val) { myTranslate = val; }
593  {
594  SOP_Node *thissop = cookparms.getNode();
595  if (!thissop) return getTranslate();
596  UT_Vector3D result;
597  OP_Utils::evalOpParm(result, thissop, "t", cookparms.getCookTime(), 0);
598  return result;
599  }
600  UT_Vector2D getScale() const { return myScale; }
601  void setScale(UT_Vector2D val) { myScale = val; }
603  {
604  SOP_Node *thissop = cookparms.getNode();
605  if (!thissop) return getScale();
606  UT_Vector2D result;
607  OP_Utils::evalOpParm(result, thissop, "s", cookparms.getCookTime(), 0);
608  return result;
609  }
610  fpreal64 getFontSize() const { return myFontSize; }
611  void setFontSize(fpreal64 val) { myFontSize = val; }
613  {
614  SOP_Node *thissop = cookparms.getNode();
615  if (!thissop) return getFontSize();
616  fpreal64 result;
617  OP_Utils::evalOpParm(result, thissop, "fontsize", cookparms.getCookTime(), 0);
618  return result;
619  }
620  UT_Vector2D getTracking() const { return myTracking; }
621  void setTracking(UT_Vector2D val) { myTracking = val; }
623  {
624  SOP_Node *thissop = cookparms.getNode();
625  if (!thissop) return getTracking();
626  UT_Vector2D result;
627  OP_Utils::evalOpParm(result, thissop, "tracking", cookparms.getCookTime(), 0);
628  return result;
629  }
630  bool getAutoKern() const { return myAutoKern; }
631  void setAutoKern(bool val) { myAutoKern = val; }
632  bool opAutoKern(const SOP_NodeVerb::CookParms &cookparms) const
633  {
634  SOP_Node *thissop = cookparms.getNode();
635  if (!thissop) return getAutoKern();
636  bool result;
637  OP_Utils::evalOpParm(result, thissop, "autokern", cookparms.getCookTime(), 0);
638  return result;
639  }
640  fpreal64 getOblique() const { return myOblique; }
641  void setOblique(fpreal64 val) { myOblique = val; }
643  {
644  SOP_Node *thissop = cookparms.getNode();
645  if (!thissop) return getOblique();
646  fpreal64 result;
647  OP_Utils::evalOpParm(result, thissop, "oblique", cookparms.getCookTime(), 0);
648  return result;
649  }
650  fpreal64 getLOD() const { return myLOD; }
651  void setLOD(fpreal64 val) { myLOD = val; }
652  fpreal64 opLOD(const SOP_NodeVerb::CookParms &cookparms) const
653  {
654  SOP_Node *thissop = cookparms.getNode();
655  if (!thissop) return getLOD();
656  fpreal64 result;
657  OP_Utils::evalOpParm(result, thissop, "lod", cookparms.getCookTime(), 0);
658  return result;
659  }
660  bool getHole() const { return myHole; }
661  void setHole(bool val) { myHole = val; }
662  bool opHole(const SOP_NodeVerb::CookParms &cookparms) const
663  {
664  SOP_Node *thissop = cookparms.getNode();
665  if (!thissop) return getHole();
666  bool result;
667  OP_Utils::evalOpParm(result, thissop, "hole", cookparms.getCookTime(), 0);
668  return result;
669  }
670  bool getAddAttrib() const { return myAddAttrib; }
671  void setAddAttrib(bool val) { myAddAttrib = val; }
672  bool opAddAttrib(const SOP_NodeVerb::CookParms &cookparms) const
673  {
674  SOP_Node *thissop = cookparms.getNode();
675  if (!thissop) return getAddAttrib();
676  bool result;
677  OP_Utils::evalOpParm(result, thissop, "addattrib", cookparms.getCookTime(), 0);
678  return result;
679  }
680 
681 private:
682  int64 myType;
683  UT_StringHolder myFontFile;
684  UT_StringHolder myText;
685  int64 myHAlign;
686  int64 myVAlign;
687  bool myUseDescender;
688  UT_Vector3D myTranslate;
689  UT_Vector2D myScale;
690  fpreal64 myFontSize;
691  UT_Vector2D myTracking;
692  bool myAutoKern;
693  fpreal64 myOblique;
694  fpreal64 myLOD;
695  bool myHole;
696  bool myAddAttrib;
697 
698 };
static void saveData(std::ostream &os, fpreal64 v)
bool opAddAttrib(const SOP_NodeVerb::CookParms &cookparms) const
bool getAutoKern() const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
UT_Vector3D getTranslate() const
void setParmValue(exint idx, const PRM_DataItemHandle &value)
bool opUseDescender(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector4D &value) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void setUseDescender(bool val)
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:492
static void loadData(UT_IStream &is, UT_Matrix3D &v)
bool operator==(const SOP_FontParms &src) const
int64 getHAlign() const
T & z(void)
Definition: UT_Vector4.h:372
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
bool opAutoKern(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2D getScale() const
void getParmValue(exint idx, UT_Matrix4D &value) const
virtual ParmType getParmType(exint fieldnum) const
static void loadData(UT_IStream &is, fpreal64 &v)
exint bread(int32 *buffer, exint asize=1)
fpreal getTime() const
Definition: OP_Context.h:34
UT_Vector2D getTracking() const
const GLdouble * v
Definition: glcorearb.h:836
void setAddAttrib(bool val)
fpreal64 opLOD(const SOP_NodeVerb::CookParms &cookparms) const
bool getUseDescender() const
void setType(int64 val)
T & x(void)
Definition: UT_Vector2.h:284
int64 opVAlign(const SOP_NodeVerb::CookParms &cookparms) const
void setHole(bool val)
void setParmValue(exint idx, const UT_Vector4D &value)
An output stream object that owns its own string buffer storage.
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void setTranslate(UT_Vector3D val)
static void loadData(UT_IStream &is, bool &v)
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
static void loadData(UT_IStream &is, UT_Vector3I &v)
virtual exint getNumParms() const
void getParmValue(exint idx, UT_StringHolder &value) const
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
virtual void copyFrom(const SOP_NodeParms *src)
bool load(UT_IStream &is)
void setParmValue(exint idx, const UT_Vector3D &value)
fpreal64 getLOD() const
static void saveData(std::ostream &os, UT_StringHolder s)
static void saveData(std::ostream &os, int64 v)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void setFontFile(const UT_StringHolder &val)
static void loadData(UT_IStream &is, UT_Vector4I &v)
void setLOD(fpreal64 val)
void getParmValue(exint idx, UT_Vector3D &value) const
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
long long int64
Definition: SYS_Types.h:100
const UT_StringHolder & getText() const
static void loadData(UT_IStream &is, UT_Vector2D &v)
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
static int version()
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
UT_Vector2D opTracking(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
int64 exint
Definition: SYS_Types.h:109
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:185
static void loadData(UT_IStream &is, UT_Vector4D &v)
void setHAlign(int64 val)
bool getAddAttrib() const
static void saveData(std::ostream &os, UT_Vector4D v)
void setParmValue(exint idx, const UT_Matrix2D &value)
virtual ~SOP_FontParms()
static void saveData(std::ostream &os, UT_Matrix2D v)
void setFontSize(fpreal64 val)
void save(std::ostream &os) const
void setParmValue(exint idx, const UT_StringHolder &value)
int64 opHAlign(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, exint &value) const
UT_StringHolder opText(const SOP_NodeVerb::CookParms &cookparms) const
GLboolean * data
Definition: glcorearb.h:130
void getParmValue(exint idx, PRM_DataItemHandle &value) const
int int32
Definition: SYS_Types.h:28
T & y(void)
Definition: UT_Vector4.h:370
void getParmValue(exint idx, UT_Matrix2D &value) const
fpreal64 opFontSize(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(exint idx, T &value) const
UT_StringHolder opFontFile(const SOP_NodeVerb::CookParms &cookparms) const
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
int64 getType() const
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
static void saveData(std::ostream &os, bool v)
const UT_StringHolder & getFontFile() const
static void loadData(UT_IStream &is, UT_Vector3D &v)
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:583
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:263
void strncpy(const char *src, exint maxlen)
int64 opType(const SOP_NodeVerb::CookParms &cookparms) const
void setTracking(UT_Vector2D val)
static void saveData(std::ostream &os, UT_Matrix4D v)
bool getHole() const
void getParmValue(exint idx, fpreal &value) const
static void loadData(UT_IStream &is, int64 &v)
void setParmValue(exint idx, const exint &value)
UT_Vector3D opTranslate(const SOP_NodeVerb::CookParms &cookparms) const
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
int64 getVAlign() const
static void saveData(std::ostream &os, UT_Vector2D v)
static void saveData(std::ostream &os, UT_Matrix3D v)
UT_Vector2D opScale(const SOP_NodeVerb::CookParms &cookparms) const
GLuint GLfloat * val
Definition: glcorearb.h:1607
Vec3< typename MatType::value_type > getScale(const MatType &mat)
Return a Vec3 representing the lengths of the passed matrix's upper 3x3's rows.
Definition: Mat.h:628
#define SOP_API
Definition: SOP_API.h:10
void getParmValue(exint idx, UT_Vector2D &value) const
const char * buffer() const
void setOblique(fpreal64 val)
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:499
static void saveData(std::ostream &os, UT_Vector3D v)
fpreal64 getOblique() const
T & x(void)
Definition: UT_Vector4.h:368
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
static void loadData(UT_IStream &is, UT_Vector2I &v)
T & y(void)
Definition: UT_Vector2.h:286
void setParmValue(exint idx, const UT_Matrix4D &value)
void setVAlign(int64 val)
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
void setText(const UT_StringHolder &val)
bool opHole(const SOP_NodeVerb::CookParms &cookparms) const
GLboolean r
Definition: glcorearb.h:1221
fpreal64 opOblique(const SOP_NodeVerb::CookParms &cookparms) const
T & w(void)
Definition: UT_Vector4.h:374
void doSetParmValue(exint idx, const T &value)
virtual const char * getParmName(exint fieldnum) const
void setScale(UT_Vector2D val)
static void loadData(UT_IStream &is, UT_StringHolder &v)
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
void setParmValue(exint idx, const fpreal &value)
void setParmValue(exint idx, const UT_Vector2D &value)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
fpreal64 getFontSize() const
SYS_FORCE_INLINE bool isstring() const
virtual void loadFromOpSubclass(const LoadParms &loadparms)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void getParmValue(exint idx, UT_Matrix3D &value) const
void setParmValue(exint idx, const UT_Matrix3D &value)
GLenum src
Definition: glcorearb.h:1792
void setAutoKern(bool val)