HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_VolumeVisualization.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 namespace SOP_VolumeVisualizationEnums
22 {
23  enum class VisMode
24  {
25  NONE = 0,
26  SMOKE,
27  HEIGHTFIELD
28  };
29  enum class Densityrampmode
30  {
31  NONE = 0,
32  CLAMP,
33  PERIODIC
34  };
35  enum class Densitypreset
36  {
37  NONE = 0,
38  INCREASING,
39  DESCREASING,
40  HILL,
41  VALLEY,
42  STEP,
43  SQUARE
44  };
45  enum class Cdrampmode
46  {
47  NONE = 0,
48  CLAMP,
49  PERIODIC
50  };
51  enum class Cdpreset
52  {
53  NONE = 0,
54  _FALSE,
55  PINK,
56  MONO,
57  BLACKBODY,
58  BIPARTITE
59  };
60  enum class Emitrampmode
61  {
62  NONE = 0,
63  CLAMP,
64  PERIODIC
65  };
66  enum class Emitpreset
67  {
68  NONE = 0,
69  INCREASING,
70  DESCREASING,
71  HILL,
72  VALLEY,
73  STEP,
74  SQUARE
75  };
76  enum class Emitcdrampmode
77  {
78  NONE = 0,
79  CLAMP,
80  PERIODIC
81  };
82  enum class Emitcdpreset
83  {
84  NONE = 0,
85  _FALSE,
86  PINK,
87  MONO,
88  BLACKBODY,
89  BIPARTITE
90  };
91 }
92 
93 
95 {
96 public:
97  static int version() { return 1; }
98 
100  {
101  myVisMode = 1;
102  myRangemin = 0;
103  myRangemax = 1;
104  myDensityscale = 1;
105  myShadowscale = 1;
106  mySetmaxres = false;
107  myMaxres = 128;
108  myDensityfield = ""_sh;
109  myDensityrampmode = 1;
110  myDensitypreset = 0;
111  myDensityramp = UT_SharedPtr<UT_Ramp>(0);
112  myCdfield = ""_sh;
113  myCdrangeoverride = false;
114  myCdrange = UT_Vector2D(0,1);
115  myCdrampmode = 1;
116  myCdpreset = 0;
117  myCdramp = UT_SharedPtr<UT_Ramp>(0);
118  myEmitscale = 0;
119  myEmitfield = ""_sh;
120  myEmitrangeoverride = false;
121  myEmitrange = UT_Vector2D(0,1);
122  myEmitrampmode = 1;
123  myEmitpreset = 0;
124  myEmitramp = UT_SharedPtr<UT_Ramp>(0);
125  myEmitcdfield = ""_sh;
126  myEmitcdrangeoverride = false;
127  myEmitcdrange = UT_Vector2D(0,1);
128  myEmitcdrampmode = 1;
129  myEmitcdpreset = 0;
130  myEmitcdramp = UT_SharedPtr<UT_Ramp>(0);
131 
132  }
133 
135 
137 
139  {
140  if (myVisMode != src.myVisMode) return false;
141  if (myRangemin != src.myRangemin) return false;
142  if (myRangemax != src.myRangemax) return false;
143  if (myDensityscale != src.myDensityscale) return false;
144  if (myShadowscale != src.myShadowscale) return false;
145  if (mySetmaxres != src.mySetmaxres) return false;
146  if (myMaxres != src.myMaxres) return false;
147  if (myDensityfield != src.myDensityfield) return false;
148  if (myDensityrampmode != src.myDensityrampmode) return false;
149  if (myDensitypreset != src.myDensitypreset) return false;
150  if (myDensityramp != src.myDensityramp) return false;
151  if (myCdfield != src.myCdfield) return false;
152  if (myCdrangeoverride != src.myCdrangeoverride) return false;
153  if (myCdrange != src.myCdrange) return false;
154  if (myCdrampmode != src.myCdrampmode) return false;
155  if (myCdpreset != src.myCdpreset) return false;
156  if (myCdramp != src.myCdramp) return false;
157  if (myEmitscale != src.myEmitscale) return false;
158  if (myEmitfield != src.myEmitfield) return false;
159  if (myEmitrangeoverride != src.myEmitrangeoverride) return false;
160  if (myEmitrange != src.myEmitrange) return false;
161  if (myEmitrampmode != src.myEmitrampmode) return false;
162  if (myEmitpreset != src.myEmitpreset) return false;
163  if (myEmitramp != src.myEmitramp) return false;
164  if (myEmitcdfield != src.myEmitcdfield) return false;
165  if (myEmitcdrangeoverride != src.myEmitcdrangeoverride) return false;
166  if (myEmitcdrange != src.myEmitcdrange) return false;
167  if (myEmitcdrampmode != src.myEmitcdrampmode) return false;
168  if (myEmitcdpreset != src.myEmitcdpreset) return false;
169  if (myEmitcdramp != src.myEmitcdramp) return false;
170 
171  return true;
172  }
174  {
175  return !operator==(src);
176  }
186 
187 
188 
189  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
190  {
191  if (true)
192  OP_Utils::evalOpParm(myVisMode, node, "vismode", time, 0);
193  else myVisMode = 1;
194  if (true)
195  OP_Utils::evalOpParm(myRangemin, node, "rangemin", time, 0);
196  else myRangemin = 0;
197  if (true)
198  OP_Utils::evalOpParm(myRangemax, node, "rangemax", time, 0);
199  else myRangemax = 1;
200  if (true)
201  OP_Utils::evalOpParm(myDensityscale, node, "densityscale", time, 0);
202  else myDensityscale = 1;
203  if (true)
204  OP_Utils::evalOpParm(myShadowscale, node, "shadowscale", time, 0);
205  else myShadowscale = 1;
206  if (true)
207  OP_Utils::evalOpParm(mySetmaxres, node, "setmaxres", time, 0);
208  else mySetmaxres = false;
209  if (true && ( (!(((getSetmaxres()==0)))) ) )
210  OP_Utils::evalOpParm(myMaxres, node, "maxres", time, 0);
211  else myMaxres = 128;
212  if (true)
213  OP_Utils::evalOpParm(myDensityfield, node, "densityfield", time, 0);
214  else myDensityfield = ""_sh;
215  if (true)
216  OP_Utils::evalOpParm(myDensityrampmode, node, "densityrampmode", time, 0);
217  else myDensityrampmode = 1;
218  if (true)
219  OP_Utils::evalOpParm(myDensitypreset, node, "densitypreset", time, 0);
220  else myDensitypreset = 0;
221  if (true && ( (!(((int64(getDensityrampmode())==0)))) ) )
222  OP_Utils::evalOpParm(myDensityramp, node, "densityramp", time, 0);
223  else myDensityramp = UT_SharedPtr<UT_Ramp>(0);
224  if (true)
225  OP_Utils::evalOpParm(myCdfield, node, "cdfield", time, 0);
226  else myCdfield = ""_sh;
227  if (true)
228  OP_Utils::evalOpParm(myCdrangeoverride, node, "cdrangeoverride", time, 0);
229  else myCdrangeoverride = false;
230  if (true && ( (!(((getCdrangeoverride()==0)))) ) )
231  OP_Utils::evalOpParm(myCdrange, node, "cdrange", time, 0);
232  else myCdrange = UT_Vector2D(0,1);
233  if (true)
234  OP_Utils::evalOpParm(myCdrampmode, node, "cdrampmode", time, 0);
235  else myCdrampmode = 1;
236  if (true)
237  OP_Utils::evalOpParm(myCdpreset, node, "cdpreset", time, 0);
238  else myCdpreset = 0;
239  if (true && ( (!(((int64(getCdrampmode())==0)))) ) )
240  OP_Utils::evalOpParm(myCdramp, node, "cdramp", time, 0);
241  else myCdramp = UT_SharedPtr<UT_Ramp>(0);
242  if (true)
243  OP_Utils::evalOpParm(myEmitscale, node, "emitscale", time, 0);
244  else myEmitscale = 0;
245  if (true)
246  OP_Utils::evalOpParm(myEmitfield, node, "emitfield", time, 0);
247  else myEmitfield = ""_sh;
248  if (true)
249  OP_Utils::evalOpParm(myEmitrangeoverride, node, "emitrangeoverride", time, 0);
250  else myEmitrangeoverride = false;
251  if (true && ( (!(((getEmitrangeoverride()==0)))) ) )
252  OP_Utils::evalOpParm(myEmitrange, node, "emitrange", time, 0);
253  else myEmitrange = UT_Vector2D(0,1);
254  if (true)
255  OP_Utils::evalOpParm(myEmitrampmode, node, "emitrampmode", time, 0);
256  else myEmitrampmode = 1;
257  if (true)
258  OP_Utils::evalOpParm(myEmitpreset, node, "emitpreset", time, 0);
259  else myEmitpreset = 0;
260  if (true && ( (!(((int64(getEmitrampmode())==0)))) ) )
261  OP_Utils::evalOpParm(myEmitramp, node, "emitramp", time, 0);
262  else myEmitramp = UT_SharedPtr<UT_Ramp>(0);
263  if (true)
264  OP_Utils::evalOpParm(myEmitcdfield, node, "emitcdfield", time, 0);
265  else myEmitcdfield = ""_sh;
266  if (true)
267  OP_Utils::evalOpParm(myEmitcdrangeoverride, node, "emitcdrangeoverride", time, 0);
268  else myEmitcdrangeoverride = false;
269  if (true && ( (!(((getEmitcdrangeoverride()==0)))) ) )
270  OP_Utils::evalOpParm(myEmitcdrange, node, "emitcdrange", time, 0);
271  else myEmitcdrange = UT_Vector2D(0,1);
272  if (true)
273  OP_Utils::evalOpParm(myEmitcdrampmode, node, "emitcdrampmode", time, 0);
274  else myEmitcdrampmode = 1;
275  if (true)
276  OP_Utils::evalOpParm(myEmitcdpreset, node, "emitcdpreset", time, 0);
277  else myEmitcdpreset = 0;
278  if (true && ( (!(((int64(getEmitcdrampmode())==0)))) ) )
279  OP_Utils::evalOpParm(myEmitcdramp, node, "emitcdramp", time, 0);
280  else myEmitcdramp = UT_SharedPtr<UT_Ramp>(0);
281 
282  }
283 
284 
285  virtual void loadFromOpSubclass(const LoadParms &loadparms)
286  {
287  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
288  }
289 
290 
291  virtual void copyFrom(const SOP_NodeParms *src)
292  {
293  *this = *((const SOP_VolumeVisualizationParms *)src);
294  }
295 
296  template <typename T>
297  void
298  doGetParmValue(exint idx, T &value) const
299  {
300  switch (idx)
301  {
302  case 0:
303  coerceValue(value, myVisMode);
304  break;
305  case 1:
306  coerceValue(value, myRangemin);
307  break;
308  case 2:
309  coerceValue(value, myRangemax);
310  break;
311  case 3:
312  coerceValue(value, myDensityscale);
313  break;
314  case 4:
315  coerceValue(value, myShadowscale);
316  break;
317  case 5:
318  coerceValue(value, mySetmaxres);
319  break;
320  case 6:
321  coerceValue(value, myMaxres);
322  break;
323  case 7:
324  coerceValue(value, myDensityfield);
325  break;
326  case 8:
327  coerceValue(value, myDensityrampmode);
328  break;
329  case 9:
330  coerceValue(value, myDensitypreset);
331  break;
332  case 10:
333  coerceValue(value, myDensityramp);
334  break;
335  case 11:
336  coerceValue(value, myCdfield);
337  break;
338  case 12:
339  coerceValue(value, myCdrangeoverride);
340  break;
341  case 13:
342  coerceValue(value, myCdrange);
343  break;
344  case 14:
345  coerceValue(value, myCdrampmode);
346  break;
347  case 15:
348  coerceValue(value, myCdpreset);
349  break;
350  case 16:
351  coerceValue(value, myCdramp);
352  break;
353  case 17:
354  coerceValue(value, myEmitscale);
355  break;
356  case 18:
357  coerceValue(value, myEmitfield);
358  break;
359  case 19:
360  coerceValue(value, myEmitrangeoverride);
361  break;
362  case 20:
363  coerceValue(value, myEmitrange);
364  break;
365  case 21:
366  coerceValue(value, myEmitrampmode);
367  break;
368  case 22:
369  coerceValue(value, myEmitpreset);
370  break;
371  case 23:
372  coerceValue(value, myEmitramp);
373  break;
374  case 24:
375  coerceValue(value, myEmitcdfield);
376  break;
377  case 25:
378  coerceValue(value, myEmitcdrangeoverride);
379  break;
380  case 26:
381  coerceValue(value, myEmitcdrange);
382  break;
383  case 27:
384  coerceValue(value, myEmitcdrampmode);
385  break;
386  case 28:
387  coerceValue(value, myEmitcdpreset);
388  break;
389  case 29:
390  coerceValue(value, myEmitcdramp);
391  break;
392 
393  }
394  }
395 
396  void getParmValue(exint idx, exint &value) const
397  { doGetParmValue(idx, value); }
398  void getParmValue(exint idx, fpreal &value) const
399  { doGetParmValue(idx, value); }
401  { doGetParmValue(idx, value); }
403  { doGetParmValue(idx, value); }
405  { doGetParmValue(idx, value); }
407  { doGetParmValue(idx, value); }
409  { doGetParmValue(idx, value); }
411  { doGetParmValue(idx, value); }
413  { doGetParmValue(idx, value); }
415  { doGetParmValue(idx, value); }
417  { doGetParmValue(idx, value); }
418 
419  template <typename T>
420  void
421  doSetParmValue(exint idx, const T &value)
422  {
423  switch (idx)
424  {
425  case 0:
426  coerceValue(myVisMode, value);
427  break;
428  case 1:
429  coerceValue(myRangemin, value);
430  break;
431  case 2:
432  coerceValue(myRangemax, value);
433  break;
434  case 3:
435  coerceValue(myDensityscale, value);
436  break;
437  case 4:
438  coerceValue(myShadowscale, value);
439  break;
440  case 5:
441  coerceValue(mySetmaxres, value);
442  break;
443  case 6:
444  coerceValue(myMaxres, value);
445  break;
446  case 7:
447  coerceValue(myDensityfield, value);
448  break;
449  case 8:
450  coerceValue(myDensityrampmode, value);
451  break;
452  case 9:
453  coerceValue(myDensitypreset, value);
454  break;
455  case 10:
456  coerceValue(myDensityramp, value);
457  break;
458  case 11:
459  coerceValue(myCdfield, value);
460  break;
461  case 12:
462  coerceValue(myCdrangeoverride, value);
463  break;
464  case 13:
465  coerceValue(myCdrange, value);
466  break;
467  case 14:
468  coerceValue(myCdrampmode, value);
469  break;
470  case 15:
471  coerceValue(myCdpreset, value);
472  break;
473  case 16:
474  coerceValue(myCdramp, value);
475  break;
476  case 17:
477  coerceValue(myEmitscale, value);
478  break;
479  case 18:
480  coerceValue(myEmitfield, value);
481  break;
482  case 19:
483  coerceValue(myEmitrangeoverride, value);
484  break;
485  case 20:
486  coerceValue(myEmitrange, value);
487  break;
488  case 21:
489  coerceValue(myEmitrampmode, value);
490  break;
491  case 22:
492  coerceValue(myEmitpreset, value);
493  break;
494  case 23:
495  coerceValue(myEmitramp, value);
496  break;
497  case 24:
498  coerceValue(myEmitcdfield, value);
499  break;
500  case 25:
501  coerceValue(myEmitcdrangeoverride, value);
502  break;
503  case 26:
504  coerceValue(myEmitcdrange, value);
505  break;
506  case 27:
507  coerceValue(myEmitcdrampmode, value);
508  break;
509  case 28:
510  coerceValue(myEmitcdpreset, value);
511  break;
512  case 29:
513  coerceValue(myEmitcdramp, value);
514  break;
515 
516  }
517  }
518 
519  void setParmValue(exint idx, const exint &value)
520  { doSetParmValue(idx, value); }
521  void setParmValue(exint idx, const fpreal &value)
522  { doSetParmValue(idx, value); }
523  void setParmValue(exint idx, const UT_Vector2D &value)
524  { doSetParmValue(idx, value); }
525  void setParmValue(exint idx, const UT_Vector3D &value)
526  { doSetParmValue(idx, value); }
527  void setParmValue(exint idx, const UT_Vector4D &value)
528  { doSetParmValue(idx, value); }
529  void setParmValue(exint idx, const UT_Matrix2D &value)
530  { doSetParmValue(idx, value); }
531  void setParmValue(exint idx, const UT_Matrix3D &value)
532  { doSetParmValue(idx, value); }
533  void setParmValue(exint idx, const UT_Matrix4D &value)
534  { doSetParmValue(idx, value); }
536  { doSetParmValue(idx, value); }
538  { doSetParmValue(idx, value); }
540  { doSetParmValue(idx, value); }
541 
542  virtual exint getNumParms() const
543  {
544  return 30;
545  }
546 
547  virtual const char *getParmName(exint fieldnum) const
548  {
549  switch (fieldnum)
550  {
551  case 0:
552  return "vismode";
553  case 1:
554  return "rangemin";
555  case 2:
556  return "rangemax";
557  case 3:
558  return "densityscale";
559  case 4:
560  return "shadowscale";
561  case 5:
562  return "setmaxres";
563  case 6:
564  return "maxres";
565  case 7:
566  return "densityfield";
567  case 8:
568  return "densityrampmode";
569  case 9:
570  return "densitypreset";
571  case 10:
572  return "densityramp";
573  case 11:
574  return "cdfield";
575  case 12:
576  return "cdrangeoverride";
577  case 13:
578  return "cdrange";
579  case 14:
580  return "cdrampmode";
581  case 15:
582  return "cdpreset";
583  case 16:
584  return "cdramp";
585  case 17:
586  return "emitscale";
587  case 18:
588  return "emitfield";
589  case 19:
590  return "emitrangeoverride";
591  case 20:
592  return "emitrange";
593  case 21:
594  return "emitrampmode";
595  case 22:
596  return "emitpreset";
597  case 23:
598  return "emitramp";
599  case 24:
600  return "emitcdfield";
601  case 25:
602  return "emitcdrangeoverride";
603  case 26:
604  return "emitcdrange";
605  case 27:
606  return "emitcdrampmode";
607  case 28:
608  return "emitcdpreset";
609  case 29:
610  return "emitcdramp";
611 
612  }
613  return 0;
614  }
615 
616  virtual ParmType getParmType(exint fieldnum) const
617  {
618  switch (fieldnum)
619  {
620  case 0:
621  return PARM_INTEGER;
622  case 1:
623  return PARM_FLOAT;
624  case 2:
625  return PARM_FLOAT;
626  case 3:
627  return PARM_FLOAT;
628  case 4:
629  return PARM_FLOAT;
630  case 5:
631  return PARM_INTEGER;
632  case 6:
633  return PARM_INTEGER;
634  case 7:
635  return PARM_STRING;
636  case 8:
637  return PARM_INTEGER;
638  case 9:
639  return PARM_INTEGER;
640  case 10:
641  return PARM_RAMP;
642  case 11:
643  return PARM_STRING;
644  case 12:
645  return PARM_INTEGER;
646  case 13:
647  return PARM_VECTOR2;
648  case 14:
649  return PARM_INTEGER;
650  case 15:
651  return PARM_INTEGER;
652  case 16:
653  return PARM_RAMP;
654  case 17:
655  return PARM_FLOAT;
656  case 18:
657  return PARM_STRING;
658  case 19:
659  return PARM_INTEGER;
660  case 20:
661  return PARM_VECTOR2;
662  case 21:
663  return PARM_INTEGER;
664  case 22:
665  return PARM_INTEGER;
666  case 23:
667  return PARM_RAMP;
668  case 24:
669  return PARM_STRING;
670  case 25:
671  return PARM_INTEGER;
672  case 26:
673  return PARM_VECTOR2;
674  case 27:
675  return PARM_INTEGER;
676  case 28:
677  return PARM_INTEGER;
678  case 29:
679  return PARM_RAMP;
680 
681  }
682  return PARM_UNSUPPORTED;
683  }
684 
685  // Boiler plate to load individual types.
686  static void loadData(UT_IStream &is, int64 &v)
687  { is.bread(&v, 1); }
688  static void loadData(UT_IStream &is, bool &v)
689  { int64 iv; is.bread(&iv, 1); v = iv; }
690  static void loadData(UT_IStream &is, fpreal64 &v)
691  { is.bread<fpreal64>(&v, 1); }
692  static void loadData(UT_IStream &is, UT_Vector2D &v)
693  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
694  static void loadData(UT_IStream &is, UT_Vector3D &v)
695  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
696  is.bread<fpreal64>(&v.z(), 1); }
697  static void loadData(UT_IStream &is, UT_Vector4D &v)
698  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
699  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
700  static void loadData(UT_IStream &is, UT_Matrix2D &v)
701  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
702  static void loadData(UT_IStream &is, UT_Matrix3D &v)
703  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
704  static void loadData(UT_IStream &is, UT_Matrix4D &v)
705  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
706  static void loadData(UT_IStream &is, UT_Vector2I &v)
707  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
708  static void loadData(UT_IStream &is, UT_Vector3I &v)
709  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
710  is.bread<int64>(&v.z(), 1); }
711  static void loadData(UT_IStream &is, UT_Vector4I &v)
712  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
713  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
715  { is.bread(v); }
717  { UT_StringHolder rampdata;
718  loadData(is, rampdata);
719  if (rampdata.isstring())
720  {
721  v.reset(new UT_Ramp());
722  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
723  v->load(istr);
724  }
725  else v.reset();
726  }
729  loadData(is, data);
730  if (data.isstring())
731  {
732  // Find the data type.
733  char *colon = UT_StringWrap(data).findChar(':');
734  if (colon)
735  {
736  int typelen = colon - data.buffer();
738  type.strncpy(data.buffer(), typelen);
739  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
740 
741  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
742  }
743  }
744  else v.reset();
745  }
746 
747  static void saveData(std::ostream &os, int64 v)
748  { UTwrite(os, &v); }
749  static void saveData(std::ostream &os, bool v)
750  { int64 iv = v; UTwrite(os, &iv); }
751  static void saveData(std::ostream &os, fpreal64 v)
752  { UTwrite<fpreal64>(os, &v); }
753  static void saveData(std::ostream &os, UT_Vector2D v)
754  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
755  static void saveData(std::ostream &os, UT_Vector3D v)
756  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
757  UTwrite<fpreal64>(os, &v.z()); }
758  static void saveData(std::ostream &os, UT_Vector4D v)
759  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
760  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
761  static void saveData(std::ostream &os, UT_Matrix2D v)
763  static void saveData(std::ostream &os, UT_Matrix3D v)
765  static void saveData(std::ostream &os, UT_Matrix4D v)
767  static void saveData(std::ostream &os, UT_StringHolder s)
768  { UT_StringWrap(s).saveBinary(os); }
769  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
770  { UT_StringHolder result;
771  UT_OStringStream ostr;
772  if (s) s->save(ostr);
773  result = ostr.str();
774  saveData(os, result);
775  }
776  static void saveData(std::ostream &os, PRM_DataItemHandle s)
777  { UT_StringHolder result;
778  UT_OStringStream ostr;
779  if (s)
780  {
781  ostr << s->getDataTypeToken();
782  ostr << ":";
783  s->saveBinary(ostr);
784  }
785  result = ostr.str();
786  saveData(os, result);
787  }
788 
789 
790  void save(std::ostream &os) const
791  {
792  int32 v = version();
793  UTwrite(os, &v);
794  saveData(os, myVisMode);
795  saveData(os, myRangemin);
796  saveData(os, myRangemax);
797  saveData(os, myDensityscale);
798  saveData(os, myShadowscale);
799  saveData(os, mySetmaxres);
800  saveData(os, myMaxres);
801  saveData(os, myDensityfield);
802  saveData(os, myDensityrampmode);
803  saveData(os, myDensitypreset);
804  saveData(os, myDensityramp);
805  saveData(os, myCdfield);
806  saveData(os, myCdrangeoverride);
807  saveData(os, myCdrange);
808  saveData(os, myCdrampmode);
809  saveData(os, myCdpreset);
810  saveData(os, myCdramp);
811  saveData(os, myEmitscale);
812  saveData(os, myEmitfield);
813  saveData(os, myEmitrangeoverride);
814  saveData(os, myEmitrange);
815  saveData(os, myEmitrampmode);
816  saveData(os, myEmitpreset);
817  saveData(os, myEmitramp);
818  saveData(os, myEmitcdfield);
819  saveData(os, myEmitcdrangeoverride);
820  saveData(os, myEmitcdrange);
821  saveData(os, myEmitcdrampmode);
822  saveData(os, myEmitcdpreset);
823  saveData(os, myEmitcdramp);
824 
825  }
826 
827  bool load(UT_IStream &is)
828  {
829  int32 v;
830  is.bread(&v, 1);
831  if (version() != v)
832  {
833  // Fail incompatible versions
834  return false;
835  }
836  loadData(is, myVisMode);
837  loadData(is, myRangemin);
838  loadData(is, myRangemax);
839  loadData(is, myDensityscale);
840  loadData(is, myShadowscale);
841  loadData(is, mySetmaxres);
842  loadData(is, myMaxres);
843  loadData(is, myDensityfield);
844  loadData(is, myDensityrampmode);
845  loadData(is, myDensitypreset);
846  loadData(is, myDensityramp);
847  loadData(is, myCdfield);
848  loadData(is, myCdrangeoverride);
849  loadData(is, myCdrange);
850  loadData(is, myCdrampmode);
851  loadData(is, myCdpreset);
852  loadData(is, myCdramp);
853  loadData(is, myEmitscale);
854  loadData(is, myEmitfield);
855  loadData(is, myEmitrangeoverride);
856  loadData(is, myEmitrange);
857  loadData(is, myEmitrampmode);
858  loadData(is, myEmitpreset);
859  loadData(is, myEmitramp);
860  loadData(is, myEmitcdfield);
861  loadData(is, myEmitcdrangeoverride);
862  loadData(is, myEmitcdrange);
863  loadData(is, myEmitcdrampmode);
864  loadData(is, myEmitcdpreset);
865  loadData(is, myEmitcdramp);
866 
867  return true;
868  }
869 
870  VisMode getVisMode() const { return VisMode(myVisMode); }
871  void setVisMode(VisMode val) { myVisMode = int64(val); }
872  VisMode opVisMode(const SOP_NodeVerb::CookParms &cookparms) const
873  {
874  SOP_Node *thissop = cookparms.getNode();
875  if (!thissop) return getVisMode();
876  int64 result;
877  OP_Utils::evalOpParm(result, thissop, "vismode", cookparms.getCookTime(), 0);
878  return VisMode(result);
879  }
880  fpreal64 getRangemin() const { return myRangemin; }
881  void setRangemin(fpreal64 val) { myRangemin = val; }
883  {
884  SOP_Node *thissop = cookparms.getNode();
885  if (!thissop) return getRangemin();
886  fpreal64 result;
887  OP_Utils::evalOpParm(result, thissop, "rangemin", cookparms.getCookTime(), 0);
888  return result;
889  }
890  fpreal64 getRangemax() const { return myRangemax; }
891  void setRangemax(fpreal64 val) { myRangemax = val; }
893  {
894  SOP_Node *thissop = cookparms.getNode();
895  if (!thissop) return getRangemax();
896  fpreal64 result;
897  OP_Utils::evalOpParm(result, thissop, "rangemax", cookparms.getCookTime(), 0);
898  return result;
899  }
900  fpreal64 getDensityscale() const { return myDensityscale; }
901  void setDensityscale(fpreal64 val) { myDensityscale = val; }
903  {
904  SOP_Node *thissop = cookparms.getNode();
905  if (!thissop) return getDensityscale();
906  fpreal64 result;
907  OP_Utils::evalOpParm(result, thissop, "densityscale", cookparms.getCookTime(), 0);
908  return result;
909  }
910  fpreal64 getShadowscale() const { return myShadowscale; }
911  void setShadowscale(fpreal64 val) { myShadowscale = val; }
913  {
914  SOP_Node *thissop = cookparms.getNode();
915  if (!thissop) return getShadowscale();
916  fpreal64 result;
917  OP_Utils::evalOpParm(result, thissop, "shadowscale", cookparms.getCookTime(), 0);
918  return result;
919  }
920  bool getSetmaxres() const { return mySetmaxres; }
921  void setSetmaxres(bool val) { mySetmaxres = val; }
922  bool opSetmaxres(const SOP_NodeVerb::CookParms &cookparms) const
923  {
924  SOP_Node *thissop = cookparms.getNode();
925  if (!thissop) return getSetmaxres();
926  bool result;
927  OP_Utils::evalOpParm(result, thissop, "setmaxres", cookparms.getCookTime(), 0);
928  return result;
929  }
930  int64 getMaxres() const { return myMaxres; }
931  void setMaxres(int64 val) { myMaxres = val; }
932  int64 opMaxres(const SOP_NodeVerb::CookParms &cookparms) const
933  {
934  SOP_Node *thissop = cookparms.getNode();
935  if (!thissop) return getMaxres();
936  int64 result;
937  OP_Utils::evalOpParm(result, thissop, "maxres", cookparms.getCookTime(), 0);
938  return result;
939  }
940  const UT_StringHolder & getDensityfield() const { return myDensityfield; }
941  void setDensityfield(const UT_StringHolder & val) { myDensityfield = val; }
943  {
944  SOP_Node *thissop = cookparms.getNode();
945  if (!thissop) return getDensityfield();
946  UT_StringHolder result;
947  OP_Utils::evalOpParm(result, thissop, "densityfield", cookparms.getCookTime(), 0);
948  return result;
949  }
950  Densityrampmode getDensityrampmode() const { return Densityrampmode(myDensityrampmode); }
951  void setDensityrampmode(Densityrampmode val) { myDensityrampmode = int64(val); }
953  {
954  SOP_Node *thissop = cookparms.getNode();
955  if (!thissop) return getDensityrampmode();
956  int64 result;
957  OP_Utils::evalOpParm(result, thissop, "densityrampmode", cookparms.getCookTime(), 0);
958  return Densityrampmode(result);
959  }
960  Densitypreset getDensitypreset() const { return Densitypreset(myDensitypreset); }
961  void setDensitypreset(Densitypreset val) { myDensitypreset = int64(val); }
963  {
964  SOP_Node *thissop = cookparms.getNode();
965  if (!thissop) return getDensitypreset();
966  int64 result;
967  OP_Utils::evalOpParm(result, thissop, "densitypreset", cookparms.getCookTime(), 0);
968  return Densitypreset(result);
969  }
970  UT_SharedPtr<UT_Ramp> getDensityramp() const { return myDensityramp; }
971  void setDensityramp(UT_SharedPtr<UT_Ramp> val) { myDensityramp = val; }
973  {
974  SOP_Node *thissop = cookparms.getNode();
975  if (!thissop) return getDensityramp();
976  UT_SharedPtr<UT_Ramp> result;
977  OP_Utils::evalOpParm(result, thissop, "densityramp", cookparms.getCookTime(), 0);
978  return result;
979  }
980  const UT_StringHolder & getCdfield() const { return myCdfield; }
981  void setCdfield(const UT_StringHolder & val) { myCdfield = val; }
983  {
984  SOP_Node *thissop = cookparms.getNode();
985  if (!thissop) return getCdfield();
986  UT_StringHolder result;
987  OP_Utils::evalOpParm(result, thissop, "cdfield", cookparms.getCookTime(), 0);
988  return result;
989  }
990  bool getCdrangeoverride() const { return myCdrangeoverride; }
991  void setCdrangeoverride(bool val) { myCdrangeoverride = val; }
992  bool opCdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
993  {
994  SOP_Node *thissop = cookparms.getNode();
995  if (!thissop) return getCdrangeoverride();
996  bool result;
997  OP_Utils::evalOpParm(result, thissop, "cdrangeoverride", cookparms.getCookTime(), 0);
998  return result;
999  }
1000  UT_Vector2D getCdrange() const { return myCdrange; }
1001  void setCdrange(UT_Vector2D val) { myCdrange = val; }
1003  {
1004  SOP_Node *thissop = cookparms.getNode();
1005  if (!thissop) return getCdrange();
1006  UT_Vector2D result;
1007  OP_Utils::evalOpParm(result, thissop, "cdrange", cookparms.getCookTime(), 0);
1008  return result;
1009  }
1010  Cdrampmode getCdrampmode() const { return Cdrampmode(myCdrampmode); }
1011  void setCdrampmode(Cdrampmode val) { myCdrampmode = int64(val); }
1013  {
1014  SOP_Node *thissop = cookparms.getNode();
1015  if (!thissop) return getCdrampmode();
1016  int64 result;
1017  OP_Utils::evalOpParm(result, thissop, "cdrampmode", cookparms.getCookTime(), 0);
1018  return Cdrampmode(result);
1019  }
1020  Cdpreset getCdpreset() const { return Cdpreset(myCdpreset); }
1021  void setCdpreset(Cdpreset val) { myCdpreset = int64(val); }
1023  {
1024  SOP_Node *thissop = cookparms.getNode();
1025  if (!thissop) return getCdpreset();
1026  int64 result;
1027  OP_Utils::evalOpParm(result, thissop, "cdpreset", cookparms.getCookTime(), 0);
1028  return Cdpreset(result);
1029  }
1030  UT_SharedPtr<UT_Ramp> getCdramp() const { return myCdramp; }
1031  void setCdramp(UT_SharedPtr<UT_Ramp> val) { myCdramp = val; }
1033  {
1034  SOP_Node *thissop = cookparms.getNode();
1035  if (!thissop) return getCdramp();
1036  UT_SharedPtr<UT_Ramp> result;
1037  OP_Utils::evalOpParm(result, thissop, "cdramp", cookparms.getCookTime(), 0);
1038  return result;
1039  }
1040  fpreal64 getEmitscale() const { return myEmitscale; }
1041  void setEmitscale(fpreal64 val) { myEmitscale = val; }
1043  {
1044  SOP_Node *thissop = cookparms.getNode();
1045  if (!thissop) return getEmitscale();
1046  fpreal64 result;
1047  OP_Utils::evalOpParm(result, thissop, "emitscale", cookparms.getCookTime(), 0);
1048  return result;
1049  }
1050  const UT_StringHolder & getEmitfield() const { return myEmitfield; }
1051  void setEmitfield(const UT_StringHolder & val) { myEmitfield = val; }
1053  {
1054  SOP_Node *thissop = cookparms.getNode();
1055  if (!thissop) return getEmitfield();
1056  UT_StringHolder result;
1057  OP_Utils::evalOpParm(result, thissop, "emitfield", cookparms.getCookTime(), 0);
1058  return result;
1059  }
1060  bool getEmitrangeoverride() const { return myEmitrangeoverride; }
1061  void setEmitrangeoverride(bool val) { myEmitrangeoverride = val; }
1062  bool opEmitrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
1063  {
1064  SOP_Node *thissop = cookparms.getNode();
1065  if (!thissop) return getEmitrangeoverride();
1066  bool result;
1067  OP_Utils::evalOpParm(result, thissop, "emitrangeoverride", cookparms.getCookTime(), 0);
1068  return result;
1069  }
1070  UT_Vector2D getEmitrange() const { return myEmitrange; }
1071  void setEmitrange(UT_Vector2D val) { myEmitrange = val; }
1073  {
1074  SOP_Node *thissop = cookparms.getNode();
1075  if (!thissop) return getEmitrange();
1076  UT_Vector2D result;
1077  OP_Utils::evalOpParm(result, thissop, "emitrange", cookparms.getCookTime(), 0);
1078  return result;
1079  }
1080  Emitrampmode getEmitrampmode() const { return Emitrampmode(myEmitrampmode); }
1081  void setEmitrampmode(Emitrampmode val) { myEmitrampmode = int64(val); }
1083  {
1084  SOP_Node *thissop = cookparms.getNode();
1085  if (!thissop) return getEmitrampmode();
1086  int64 result;
1087  OP_Utils::evalOpParm(result, thissop, "emitrampmode", cookparms.getCookTime(), 0);
1088  return Emitrampmode(result);
1089  }
1090  Emitpreset getEmitpreset() const { return Emitpreset(myEmitpreset); }
1091  void setEmitpreset(Emitpreset val) { myEmitpreset = int64(val); }
1093  {
1094  SOP_Node *thissop = cookparms.getNode();
1095  if (!thissop) return getEmitpreset();
1096  int64 result;
1097  OP_Utils::evalOpParm(result, thissop, "emitpreset", cookparms.getCookTime(), 0);
1098  return Emitpreset(result);
1099  }
1100  UT_SharedPtr<UT_Ramp> getEmitramp() const { return myEmitramp; }
1101  void setEmitramp(UT_SharedPtr<UT_Ramp> val) { myEmitramp = val; }
1103  {
1104  SOP_Node *thissop = cookparms.getNode();
1105  if (!thissop) return getEmitramp();
1106  UT_SharedPtr<UT_Ramp> result;
1107  OP_Utils::evalOpParm(result, thissop, "emitramp", cookparms.getCookTime(), 0);
1108  return result;
1109  }
1110  const UT_StringHolder & getEmitcdfield() const { return myEmitcdfield; }
1111  void setEmitcdfield(const UT_StringHolder & val) { myEmitcdfield = val; }
1113  {
1114  SOP_Node *thissop = cookparms.getNode();
1115  if (!thissop) return getEmitcdfield();
1116  UT_StringHolder result;
1117  OP_Utils::evalOpParm(result, thissop, "emitcdfield", cookparms.getCookTime(), 0);
1118  return result;
1119  }
1120  bool getEmitcdrangeoverride() const { return myEmitcdrangeoverride; }
1121  void setEmitcdrangeoverride(bool val) { myEmitcdrangeoverride = val; }
1122  bool opEmitcdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
1123  {
1124  SOP_Node *thissop = cookparms.getNode();
1125  if (!thissop) return getEmitcdrangeoverride();
1126  bool result;
1127  OP_Utils::evalOpParm(result, thissop, "emitcdrangeoverride", cookparms.getCookTime(), 0);
1128  return result;
1129  }
1130  UT_Vector2D getEmitcdrange() const { return myEmitcdrange; }
1131  void setEmitcdrange(UT_Vector2D val) { myEmitcdrange = val; }
1133  {
1134  SOP_Node *thissop = cookparms.getNode();
1135  if (!thissop) return getEmitcdrange();
1136  UT_Vector2D result;
1137  OP_Utils::evalOpParm(result, thissop, "emitcdrange", cookparms.getCookTime(), 0);
1138  return result;
1139  }
1140  Emitcdrampmode getEmitcdrampmode() const { return Emitcdrampmode(myEmitcdrampmode); }
1141  void setEmitcdrampmode(Emitcdrampmode val) { myEmitcdrampmode = int64(val); }
1143  {
1144  SOP_Node *thissop = cookparms.getNode();
1145  if (!thissop) return getEmitcdrampmode();
1146  int64 result;
1147  OP_Utils::evalOpParm(result, thissop, "emitcdrampmode", cookparms.getCookTime(), 0);
1148  return Emitcdrampmode(result);
1149  }
1150  Emitcdpreset getEmitcdpreset() const { return Emitcdpreset(myEmitcdpreset); }
1151  void setEmitcdpreset(Emitcdpreset val) { myEmitcdpreset = int64(val); }
1153  {
1154  SOP_Node *thissop = cookparms.getNode();
1155  if (!thissop) return getEmitcdpreset();
1156  int64 result;
1157  OP_Utils::evalOpParm(result, thissop, "emitcdpreset", cookparms.getCookTime(), 0);
1158  return Emitcdpreset(result);
1159  }
1160  UT_SharedPtr<UT_Ramp> getEmitcdramp() const { return myEmitcdramp; }
1161  void setEmitcdramp(UT_SharedPtr<UT_Ramp> val) { myEmitcdramp = val; }
1163  {
1164  SOP_Node *thissop = cookparms.getNode();
1165  if (!thissop) return getEmitcdramp();
1166  UT_SharedPtr<UT_Ramp> result;
1167  OP_Utils::evalOpParm(result, thissop, "emitcdramp", cookparms.getCookTime(), 0);
1168  return result;
1169  }
1170 
1171 private:
1172  int64 myVisMode;
1173  fpreal64 myRangemin;
1174  fpreal64 myRangemax;
1175  fpreal64 myDensityscale;
1176  fpreal64 myShadowscale;
1177  bool mySetmaxres;
1178  int64 myMaxres;
1179  UT_StringHolder myDensityfield;
1180  int64 myDensityrampmode;
1181  int64 myDensitypreset;
1182  UT_SharedPtr<UT_Ramp> myDensityramp;
1183  UT_StringHolder myCdfield;
1184  bool myCdrangeoverride;
1185  UT_Vector2D myCdrange;
1186  int64 myCdrampmode;
1187  int64 myCdpreset;
1188  UT_SharedPtr<UT_Ramp> myCdramp;
1189  fpreal64 myEmitscale;
1190  UT_StringHolder myEmitfield;
1191  bool myEmitrangeoverride;
1192  UT_Vector2D myEmitrange;
1193  int64 myEmitrampmode;
1194  int64 myEmitpreset;
1195  UT_SharedPtr<UT_Ramp> myEmitramp;
1196  UT_StringHolder myEmitcdfield;
1197  bool myEmitcdrangeoverride;
1198  UT_Vector2D myEmitcdrange;
1199  int64 myEmitcdrampmode;
1200  int64 myEmitcdpreset;
1201  UT_SharedPtr<UT_Ramp> myEmitcdramp;
1202 
1203 };
bool opEmitrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
void setParmValue(exint idx, const UT_Vector3D &value)
Emitpreset opEmitpreset(const SOP_NodeVerb::CookParms &cookparms) const
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:494
T & z(void)
Definition: UT_Vector4.h:379
fpreal64 opEmitscale(const SOP_NodeVerb::CookParms &cookparms) const
virtual const char * getParmName(exint fieldnum) const
UT_SharedPtr< UT_Ramp > opEmitcdramp(const SOP_NodeVerb::CookParms &cookparms) const
exint bread(int32 *buffer, exint asize=1)
UT_SharedPtr< UT_Ramp > opDensityramp(const SOP_NodeVerb::CookParms &cookparms) const
GT_API const UT_StringHolder time
fpreal getTime() const
Definition: OP_Context.h:60
const GLdouble * v
Definition: glcorearb.h:836
UT_Vector2T< fpreal64 > UT_Vector2D
bool operator==(const SOP_VolumeVisualizationParms &src) const
void save(std::ostream &os) const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
void doSetParmValue(exint idx, const T &value)
SYS_FORCE_INLINE const char * buffer() const
T & x(void)
Definition: UT_Vector2.h:285
UT_SharedPtr< UT_Ramp > opEmitramp(const SOP_NodeVerb::CookParms &cookparms) const
An output stream object that owns its own string buffer storage.
Cdpreset opCdpreset(const SOP_NodeVerb::CookParms &cookparms) const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
void setEmitcdfield(const UT_StringHolder &val)
UT_StringHolder opEmitcdfield(const SOP_NodeVerb::CookParms &cookparms) const
UT_SharedPtr< UT_Ramp > getEmitcdramp() const
void setParmValue(exint idx, const fpreal &value)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:498
UT_SharedPtr< UT_Ramp > getDensityramp() const
bool opEmitcdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void getParmValue(exint idx, UT_Matrix3D &value) const
Densityrampmode opDensityrampmode(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector2D &value) const
fpreal64 opDensityscale(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setParmValue(exint idx, const PRM_DataItemHandle &value)
UT_SharedPtr< UT_Ramp > getEmitramp() const
void setDensityramp(UT_SharedPtr< UT_Ramp > val)
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
UT_SharedPtr< UT_Ramp > opCdramp(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opShadowscale(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Matrix2D &value)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:502
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
fpreal64 opRangemin(const SOP_NodeVerb::CookParms &cookparms) const
long long int64
Definition: SYS_Types.h:107
UT_StringHolder opDensityfield(const SOP_NodeVerb::CookParms &cookparms) const
Emitrampmode opEmitrampmode(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void setParmValue(exint idx, const UT_StringHolder &value)
int64 opMaxres(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2D opEmitrange(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(exint idx, T &value) const
static void saveData(std::ostream &os, int64 v)
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
bool operator!=(const SOP_VolumeVisualizationParms &src) const
static void loadData(UT_IStream &is, fpreal64 &v)
UT_Vector2D opEmitcdrange(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
static void loadData(UT_IStream &is, UT_Vector4I &v)
int64 exint
Definition: SYS_Types.h:116
static void saveData(std::ostream &os, UT_Matrix3D v)
static void saveData(std::ostream &os, UT_Matrix4D v)
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
UT_SharedPtr< UT_Ramp > getCdramp() const
double fpreal64
Definition: SYS_Types.h:192
static void loadData(UT_IStream &is, UT_Matrix4D &v)
static void loadData(UT_IStream &is, bool &v)
static void saveData(std::ostream &os, UT_Matrix2D v)
void setParmValue(exint idx, const UT_Matrix3D &value)
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool opCdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
void setEmitramp(UT_SharedPtr< UT_Ramp > val)
UT_Vector2D opCdrange(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getEmitcdfield() const
GLboolean * data
Definition: glcorearb.h:130
void setDensityfield(const UT_StringHolder &val)
int int32
Definition: SYS_Types.h:35
T & y(void)
Definition: UT_Vector4.h:377
static void saveData(std::ostream &os, UT_Vector2D v)
static void saveData(std::ostream &os, fpreal64 v)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
void setParmValue(exint idx, const UT_Vector4D &value)
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
fpreal64 opRangemax(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:500
GLsizei const GLfloat * value
Definition: glcorearb.h:823
static void loadData(UT_IStream &is, UT_Vector3I &v)
double fpreal
Definition: SYS_Types.h:270
UT_StringHolder opCdfield(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
void getParmValue(exint idx, UT_Matrix2D &value) const
virtual void copyFrom(const SOP_NodeParms *src)
Emitcdrampmode opEmitcdrampmode(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector4D v)
Densitypreset opDensitypreset(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Matrix4D &value)
static void loadData(UT_IStream &is, UT_StringHolder &v)
void getParmValue(exint idx, PRM_DataItemHandle &value) const
const UT_StringHolder & getDensityfield() const
void setCdramp(UT_SharedPtr< UT_Ramp > val)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
void setCdfield(const UT_StringHolder &val)
GLuint GLfloat * val
Definition: glcorearb.h:1607
void getParmValue(exint idx, UT_Vector3D &value) const
#define SOP_API
Definition: SOP_API.h:10
virtual ParmType getParmType(exint fieldnum) const
Emitcdpreset opEmitcdpreset(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, bool v)
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:501
T & x(void)
Definition: UT_Vector4.h:375
void getParmValue(exint idx, UT_Matrix4D &value) const
T & y(void)
Definition: UT_Vector2.h:287
static void saveData(std::ostream &os, UT_Vector3D v)
const UT_StringHolder & getEmitfield() const
UT_StringHolder opEmitfield(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const exint &value)
const UT_StringHolder & getCdfield() const
void setEmitcdramp(UT_SharedPtr< UT_Ramp > val)
GLboolean r
Definition: glcorearb.h:1221
void getParmValue(exint idx, UT_Vector4D &value) const
T & w(void)
Definition: UT_Vector4.h:381
static void loadData(UT_IStream &is, UT_Vector3D &v)
void getParmValue(exint idx, UT_StringHolder &value) const
static void saveData(std::ostream &os, UT_StringHolder s)
void setDensityrampmode(Densityrampmode val)
bool opSetmaxres(const SOP_NodeVerb::CookParms &cookparms) const
void setEmitfield(const UT_StringHolder &val)
static void loadData(UT_IStream &is, UT_Vector4D &v)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
void setParmValue(exint idx, const UT_Vector2D &value)
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:88
void getParmValue(exint idx, exint &value) const
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
SYS_FORCE_INLINE bool isstring() const
void getParmValue(exint idx, fpreal &value) const
static void loadData(UT_IStream &is, int64 &v)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
virtual void loadFromOpSubclass(const LoadParms &loadparms)
Cdrampmode opCdrampmode(const SOP_NodeVerb::CookParms &cookparms) const
GLenum src
Definition: glcorearb.h:1792
VisMode opVisMode(const SOP_NodeVerb::CookParms &cookparms) const